Программа сценарий матлаб

Программы-сценарии (скрипты) в MATLAB используют рабочую область программы, из которой они были вызваны, что можно использовать для передачи параметров скриптам. Например напишем скрипт, вычисляющий гипотенузу прямоугольного треугольника:

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

% a, b — катеты прямоугольного треугольника

% с — вычисляемая гипотенуза

% промежуточные расчеты

x = a^2 + b^2;

% вычисляем гипотенузу

c = sqrt(x);

Пример использования данного скрипта:

a = 3;

b = 4;

hypScr

c

c =

x

x =

То есть, вызванные из консоли переменные a и b были созданы в базовой рабочей области. Далее из консоли вызывается программа-сценарий (скрипт) hypScr, которая в базовой рабочей области создаст переменные с и х, используя ранее созданные переменные а и b.

У данного подхода имеются следующие недостатки:

• необходимо заранее создать переменные с заранее заданными именами (a, b);
• после вычислений появится ненужная переменная x;
• все четыре переменные (a, b, c и x) могут использоваться в коде ранее и в них могут уже содержаться данные, которые нельзя терять, поэтому неосторожное использование скриптов может привести к возникновению ошибок.

<p>Этих недостатков лишены функции:

function c = hypFun( a, b )

% функция, вычисляющая гипотенузу прямоугольного треугольника

% a, b — катеты прямоугольного треугольника, скаляры

% с — вычисляемая гипотенуза, скаляр

% промежуточные расчеты

x = a^2 + b^2;

% вычисляем гипотенузу

c = sqrt(x);

end

Пример использования данной функции:

a = 2; % некие важные данные, которые нужно сохранить

x = 3; % некие важные данные, которые нужно сохранить, со скриптом это не получится

c = hypFun(3,4)

c =

a

a =

x

x =

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

Передача параметров по значению

В MATLAB параметры всегда передаются по значению. Передача по значению означает, что вызывающая функция копирует в рабочую область функции непосредственное значение параметра. Изменение копии переменной, соответственно, оригинал не затрагивает.

Приведем пример. Функция demoTrFun:

function [ ] = demoTrFun( x )

% демонстрация передачи параметров по значению

% увеличим переменную x

x = x + 5;

end

Демонстрация использования данной функции:

x = 0; % создадим переменную x

demoTrFun(x); % вызовем тестовую функцию, чтобы показать передачу по значению

x % покажем, что действительно была передана копия переменной x (x не должна изменится)

x =

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

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

function [ res ] = myGCD( a, b )

% вычисление наибольшего общего делителя чисел a и b

% проверка, что числа a и b не имеют дробных частей

if a ~= round(a) || b ~= round(b)

error(‘Входные аргументы должны быть целыми’);

end

while a ~= b

if ab

a = a — b;

else

b = b — a;

end

end

% сохранить результат в выходную переменную

res = a;

end

Пример использования этой функции:

myGCD(78, 66)

ans =

myGCD(32, 48.5)

Error using myGCD (line 6)

Входные аргументы должны быть целыми

Анонимные функции

В MATLAB существует еще один вид функций, так называемые анонимные функции. Эти функции не имеют файла определения, а лишь ассоциированы с переменной, имеющей тип function_handle. Обращение к анонимным функциям (АФ) производится с помощью данных переменных.

Создадим АФ, вычисляющую квадрат числа:

sqr = @(x) x.^2;

Теперь квадрат 5 можно вычислить следующим образом

sqr(5)

ans =

Ограничением для функций является то, что при определении тела АФ может быть использовано только одно выражение. Внутри АФ могут вызываться другие функции, в том числе и другие анонимные. Нельзя использовать управляющие конструкции условия и цикла.

При написании тела функции могут использоваться переменные, уже существующие в рабочем пространстве. Значения данных переменных будут сохранены в определении АФ и использоваться независимо от своих глобальных определений. Даже если вы удалите переменные после того, как определили АФ, значения данных переменных будут использованы при выполнении функции.

a = -1.3; b = .2; c = 30;

parabola = @(x) a*x.^2 + b*x + c;

clear a b c

x = 1;

y = parabola(1)

y =

31.5000

Если есть необходимость изменить значения используемых переменных, то придется создать АФ заново.

a = -1.3; b = .2; c = 30;

parabola = @(x) a*x.^2 + b*x + c;

a = -3.9; b = 52; c = 0;

parabola = @(x) a*x.^2 + b*x + c; % Создание АФ с новыми значениями a, b, c

x = 1;

y = parabola(1)

y =

48.1000

Сравнения таких объектов MATLAB, как скрипт, функция и анонимная функция, приведено в таблице 3.1.

Таблица 3.1. Сравнение программ-сценариев, функций и анонимных функций

	Объявление	Вызов	Рабочая область	Где хранится
Программа-сценарий (скрипт)	Построчное написание	name	base	Файл с расширением .m
Функция	function []=name() end	[]=name()	function	Файл с расширением .m
Анонимная функция	name=@(x)f(x)	a=name()	function	Переменная типаfunction_handle

Статьи к прочтению:

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

03 Написание программы MATLAB

Похожие статьи:

• M-файлы, программ и функций

  Тема 3.4.М-файлы и программирование средствами MatLab Основные понятия и средства программированиям в MatLab M-файлы, программ и функций Работа с…

• Объявление (или описание) функции в программе.

  Вопрос Вопрос Пример: Если или Вопрос mkdir команда для создания новых каталогов$ mkdir имя_каталогаилиmkdir имя_каталога1 имя_каталога2 имя_каталога3…

1.
Понятия функции и сценария.
Работая в
интерактивном режиме, приходится всё
время вводить нужные команды с клавиатуры.
Затем, в следующих сеансах работы с
системой MATLAB,
можно командой load
ввести из
MAT-файла
ранее сохранённую информацию о переменных,
с которыми ранее осуществлялись
вычисления. Однако команды для её
обработки потребуется заново вводить
с клавиатуры.

Это
вполне приемлемо, когда заранее неизвестен
порядок обработки информации, или когда
объём такой обработки невелик и
повторяется редко. Если же порядок
обработки информации заранее известен
и её надо осуществлять многократно, то
лучше последовательность команд оформить
в виде сценария.

С
ценарий
— это текстовый файл, в котором в нужном
порядке записаны команды, подлежащие
последовательному выполнению. Создать
такой файл можно с помощью любого
текстового редактора, но система MATLAB
располагает собственным текстовым
редактором для этих целей, который к
тому же обеспечивает дополнительные
удобства. В результате лучше всего
пользоваться именно этим редактором.
Он вызывается командой меню File
| New | M-file
и работает в своём собственном окне:

С


ценарий
производит вычисления как с переменными,
которые определяются непосредственно
внутри него, так и с переменными, ранее
определёнными в рабочем пространстве
системы MATLAB.
Таким образом, пространство переменных
у них общее.

После
создания сценария его надо сохранить
в файле на диске. Этот файл может иметь
произвольное имя (желательно, чтобы оно
не совпало с именами файлов, входящих
в стандартную поставку системы MATLAB),
но расширение имени должно состоять из
одной буквы m
(например,
myScript1.m
и тому
подобное).
По этой причине принято говорить, что
сценарии хранятся в M-файлах.
Их не надо путать с MAT-файлами,
изученными ранее и в которых хранятся
переменные из рабочего пространства
системы MATLAB.

Каталог
на диске для хранения M-файлов
может быть любым, но путь к этому каталогу
обязательно должен быть известен
MATLABу.
MATLAB
хранит сведения обо всех таких каталогах.
Для нового каталога надо выполнить
команду меню (командного окна) File
| Set Path…, с
помощью которого вызывается диалоговое
окно с именем Path
Browser (Просмотрщик
путей доступа
к файлам):

В

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

Path
| Add to path..

После
того, как мы добавили новый каталог, в
нём можно сохранить файл с созданным в
редакторе сценарием. Сохранёный таким
образом сценарий в любой момент можно
выполнить целиком (то есть выполнить
за один раз все команды, входящие в этот
сценарий), если набрать в командном окне
имя файла (без расширения), содержащего
сценарий, и нажать клавишу Enter.

Ещё
раз напомним, что сценарий обрабатывает
как свои собственные переменные, так и
переменные, определённые до вызова
сценария в командном окне системы MATLAB
и хранящиеся в её рабочем пространстве.
Сценарию нельзя в момент его вызова
передать для обработки в виде параметров
дополнительную информацию, не содержащуюся
в рабочем пространстве.

Чтобы
сделать возможным передачу для дальнейшей
обработки входных параметров, а также
разделить рабочие пространства, нужно
вместо сценария написать функцию.
Функции реализуют определённый алгоритм
обработки входной информации и идеально
приспособлены для решения отдельных
задач, которые в совокупности позволяют
разрешить некоторую крупную проблему.

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

Функции,
как и сценарии, состоят из команд и их
записывают в текстовые файлы с расширением
m.
Поэтому
их для лаконичности (в любой отрасли
знаний применяется свой профессиональный
жаргон) называют M-функциями.

Сейчас
мы подробно рассмотрим все особенности
устройства M-функций.

2.
Синтаксис определения и вызова M-функций.
Текст
M-функции
должен начинаться с заголовка,
после которого следует тело
функции.

Заголовок
определяет »
интерфейс»
функции
(способ взаимодействия с ней) и устроен
следующим образом:

function
[ RetVal1, RetVal2,… ] = FunctionName( par1, par2,… )

Здесь
провозглашается функция (с помощью
неизменного «ключевого»
слова function)
с именем
FunctionName,
которая
принимает входные параметры par1,
par2,…,
и вырабатывает
(вычисляет) выходные (возвращаемые)
значения RetVal1,
RetVal2…

По-другому
говорят, что аргументами
функции
являются переменные par1,
par2,..,
а значениями
функции (их
надо вычислить) являются переменные
RetVal1,
RetVal2,… .

Указанное
в заголовке имя функции (в приведённом
примере — FunctionName)
должно
служить именем файла, в который будет
записан текст функции. Для данного
примера это будет файл FunctionName.m
(расширение
имени, по-прежнему, должно состоять лишь
из одной буквы m).
Рассогласования
имени функции и имени файла не допускается!

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

Как
входные параметры, так и возвращаемые
значения могут быть в общем случае
массивами (в частном случае — скалярами)
различных размерностей и размеров.
Например, функция
MatrProc1

function
[ A, B ] = MatrProc1( X1, X2, x )

A
= X1 .* X2 * x;

B
= X1 .* X2 + x;

рассчитана
на «приём»
двух массивов одинаковых (но произвольных)
размеров и одного скаляра.

Эти
массивы в теле функции сначала
перемножаются поэлементно, после чего
результат такого перемножения ещё
умножается на скаляр. Таким образом
порождается первый из выходных массивов.
Одинаковые размеры входных масивов X1
и X2
гарантируют выполнимость операции их
поэлементного умножения. Второй выходной
массив (с именем B)
отличается
от первого тем, что получается сложением
со скаляром (а не умножением).

Вызов
созданной нами функции
осуществляется из командного окна
системы MATLAB
(или из
текста какой-либо другой функции) обычным
образом:
записывается имя функции, после которого
в круглых скобках через запятую
перечисляются фактические
входные
параметры,
со значениями которых и будут произведены
вычисления. Фактические параметры могут
быть заданы числами (массивами чисел),
именами переменных, уже имеющими
конкретные значения, а также выражениями.

Если
фактический параметр задан именем
некоторой переменной, то реальные
вычисления будут производиться с копией
этой переменной (а не с ней самой). Это
называется передачей
параметров по значению.

Ниже
показан вызов из командного окна MATLABа
ранее созданной нами для примера функции
MatrProc1.

З
десь
имена фактических входных параметров
(W1
и W2)
и переменных,
в которых записываются результаты
вычислений ( Res1
и Res2
), не
совпадают с именами аналогичных
переменных в определении функции
MatrProc1.
Очевидно, что совпадения и не требуется,
тем более, что у третьего входного
фактического параметра нет имени вообще!
Чтобы подчеркнуть это возможное отличие,
имена входных параметров и выходных
значений в определении функции называют
формальными.

В
рассмотренном примере вызова функции
MatrProc1
из двух входных квадратных матриц 2
x 2
получаются
две выходные матрицы Res1
и Res2
точно таких же размеров:

Res1
=

9
6

1. 6

Res2
=

6
5

5
5

Вызвав
функцию MatrProc1

[r1,r2]
= MatrProc1( [ 1 2 3; 4 5 6 ], [ 7 7 7; 2 2 2 ], 1 );

с
двумя входными массивами размера 2×3,
получим
две выходные матрицы размера 2×3.
То есть,
одна и та же функция MatrProc1
может
обрабатывать входные параметры различных
размеров и размерностей! Можно вместо
массивов применить эту функцию к скалярам
(это всё равно массивы размера 1×1).

Т
еперь
рассмотрим вопрос о том, можно ли
использовать эту функцию в составе
выражений так, как это делается с
функциями, возвращающими единственное
значение?
Оказывается
это делать можно, причём в качестве
значения функции, применяемого для
дальнейших вычислений, используется
первое из возвращаемых функцией значений.
Следующее окно системы MATLAB
иллюстрирует
это положение:

При
вызове с параметрами 1,2,1 функция MatrProc1
возвращает
два значения:
2 и 3. Для использования в составе выражения
используется первое из них.

Так
как вызов любой функции можно осуществить,
написав произвольное выражение в
командном окне MATLABа,
то всегда можно совершить ошибку,
связанную с несовпадением типов
фактических и формальных параметров.
MATLAB
не выполняет никаких проверок на эту
тему, а просто передаёт управление
функции. В результате могут возникнуть
ошибочные ситуации. Чтобы избежать
(по-возможности) возникновения таких
ошибочных ситуаций, предлагается в
тексте M-функций
осуществлять проверку входных параметров.
Например, в функции MatrProc1
легко
осуществить выявление ситуации, когда
размеры первого и второго входных
параметров различны. Для написания
такого кода требуются конструкции
управления, которые мы пока ещё не
изучали. Самое время приступить к их
изучению!

3.
Конструкции управления.
В любом языке
программирования, в том числе и в языке
программирования, встроенном в систему
MATLAB
(его часто
называют M-языком),
имеются специальные конструкции, которые
задаются с помощью зарезервированных
ключевых слов этого языка и служат для
управления порядком выполнения операций.

Такие
конструкции часто называют операторами
управления. К джентльменскому набору
операторов управления относятся
операторы
ветвления
и операторы
цикла. Начнёс
с операторов ветвления.

К
операторам ветвления в M-языке
относятся условный
оператор и
оператор
переключения.
Условный оператор использует ключевые
слова

if
(«если»),
else
(«иначе»)

elseif
(«иначе
если»),
end
(«конец
всей конструкции»)

и
может выступать в одной из следующих
трёх форм.

Во-первых,

if
условие

…

end

Во-вторых,

if
условие

…

else

…

end

И, наконец, в форме

if
условие1

…

elseif
условие2

…

else

…

end

в
которой ветвей с ключевым словом
elseif
может
быть много.

Область
действия условного оператора начинается
ключевым словом
if,
а
заканчивается ключевым словом
end.
Под
условием
понимается
произвольное выражение (чаще всего это
выражение включает в себя операции
сравнения и логические операции),
истинность или ложность которого
понимается как отличие или равенство
нулю.

Если
условие истинно, то выполняются команды,
стоящие после строки с ключевым словом
if.
Если условие
ложно, то эти команды пропускаются и
переходят либо к следующему за условным
оператору (первая форма), либо проверяют
ещё одно условие в строке с ключевым
словм elseif
(третья
форма условного оператора),
либо
выполняются без дополнительных проверок
команды, стоящие после строки с ключевым
словом else
(вторая из приведённых выше форм). Более
побробных объяснений по
работе условного оператора не
требуется, так как перевод ключевых
слов говорит сам за себя.

Однако
требуются ещё кое-какие разъяснения,
связанные с тотальным использованием
в M-языке
системы MATLAB
массивов. Их можно использовать и в
условных выражениях, входящих в условные
операторы MATLABа.
В тех случаях, когда значением таких
выражений будет массив, истинность
условия
наступает, когда истинны
(не равны
нулю) все
элементы массива.
Если хоть один элемент такого массива
будет равен нулю, то условие считается
ложным. Кроме того, ложность имеет место
при использовании пустых
массивов.

Приведём
иллюстрирующий работу условного
оператора фрагмент кода

A
= [ 1 2; 4 0 ];

if
A

b
= 1;

else

b
=2;

в
результате выполнения которого переменная
b
получит значение 2,
так как матрица A
содержит один нулевой элемент, и всё
условие считается ложным.

Кстати,
запись if
A по
своему действию
полностью
эквивалентна записи if
A~=0
и записи
if
all( A( : ) ).

Оператор
переключения использует ключевые слова
switch
(«переключить»),
case
(«случай»),
otherwise
(«иначе»)
и имеет
следующую конструкцию:

switch
выражение

case
значение1

…

case
{ значение2,
значение3
}

…

…

otherwise

…

end

Сначала
вычисляется вырабатывающее скалярное
числовое
значение выражение,
а затем полученный результат сравнивается
с набором значений значение1,
значение2,
значение3
и
так далее. В случае совпадения с одним
из значений, выполняется нижестоящая
ветка. Если нет совпадения ни с каким
из перечисленных значений, то выполняется
ветка, стоящая после ключевого слова
otherwise. Строк
с ключевым словом case
может быть
много, а строка с ключевым словм otherwise
— одна.

Теперь
рассмотрим операторы цикла, призванные
циклически повторять участки программного
кода. В зависимости от способа определения
условия останова повторов различают
два вида операторов цикла в M-языке
системы MATLAB.

Первый
из них использует ключевые слова for
(«для»)
и end.
Он имеет
вид

while
выражение

…

end

Здесь
повтор участка кода, обозначенного
многоточием, продолжается пока выражение
истинно
(не равно нулю).
В случае массивов истинность наступает,
когда все элементы массива истинны.

Следующий
фрагмент вычисляет сумму отрезка ряда:

S=0;
k=1; u=1;

while
u > 1e-8

S
= S + u;

k
= k + 1; u = 1/k^2;

end

Условием
останова служит требование к очередным
слагаемым быть больше некоторого заранее
определённого числа:
как только слагаемое станет меньше
этого числа, суммирование прекратится.

Другой
вариант оператора цикла использует
ключевые слова for
(» для»)
и end.
Он имеет
вид:

for
varName = выражение

…

end

где
varName
— произвольно
выбираемое программистом имя так
называемой переменной
цикла. В
отличие от первого варианта оператора
цикла здесь легко прогнозировать
количество итераций (повторов), так как
тело цикла (обозначено многоточием)
выполняется для всех возможных значений
переменной varName.
Набор
возможных значений для переменной цикла
поставляет выражение.

Чаще
всего выражение
представлено с помощью ранее изученной
операции «диапазон
значений«.
В следующем
фрагменте кода осуществляется сложение
57 членов ряда:

S=0;

for
k = 1 : 1 : 57

S
= S + 1/k^2;

end

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

Вместо операции задания диапазона можно
явно указывать весь набор возможных
значений в виде вектор-строки, например

for
m = [ 2, 5, 7, 8, 11, 23 ]

что
приведёт к шести итерациям. При первой
итерации переменная цикла m
будет равна 2, при втором — 5 и так далее
до исчерпания всех возможных значений.

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

A
= [ 1 2; 3 4];

for
k = A

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

Например, следующий
фрагмент

S=0;
A = [ 1 2; 3 4];

for
k = A

S
= S + sqrt( k(1)^2 + k(2)^2 );

end

вычисляет
сумму «длин»
столбцов
матрицы A.

Оба
вида операторов цикла можно прервать,
если применить оператор break
внутри тела цикла.

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

k=0;

for
x = 0 : 0.1 :100

k=k+1;
y( k ) = cos( x );

end

лучше
использовать операции с массивами:

x
= 0 : 0.1 : 100; y = cos( x );

так как они быстрее
исполняются и записываются короче.

4.
Проверка входных параметров и выходных
значений M-функции.
Как мы
говорили выше, несовпадение типов и
числа фактических и формальных параметров
в M-функции
приводит к их неправильной работе. Но
«пользователь»
M-функции
всегда может ошибиться при её вызове.
Поэтому желательно встраивать внутрь
кода M-функций
проверки входных параметров.

Ранее
рассмотренная в пункте 2 функция MatrProc1
предполагала использовать в качестве
первого и второго аргументов массивы
одинаковых размеров. Если пользователь
по ошибке задаст фактические параметры
в виде массивов разных размеров, то в
процессе выполнения функции возникнет
ошибка. Чтобы избежать этого, можно в
теле функции MatrProc1
организовать
проверку размеров первого и второго
параметров:

function [ A,
B ] = MatrProc1( X1, X2, x )

if
size( X1 ) ~= size( X2 )

error(
‘Bad 1st and 2nd parameters’ )

end

A
= X1 .* X2 * x;

B
= X1 .* X2 + x;

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

Затем
нужно добавить ещё проверку третьего
параметра на скалярность, что можно
выполнить следующим фрагментом кода:

[
m ,n ] = size( x );

if
(
m ~=1 | n ~= 1 )

error(
‘Bad 3d parameter’ )

end

Наконец,
неплохо проверить общее число параметров,
с которыми функция была вызвана. Для
этой цели в системе MATLAB
специально
предусмотрена переменная с именем
nargin.
Её значением
является количество аргументов,
фактически переданное функции при
вызове. Тогда проверка на число параметров
выполняется следующим образом:

if
nargin ~= 3

error(
‘Bad number of parameters’ )

end

Более
того, в системе MATLAB
предусмотрена переменная nargout,
содержащая число возвращаемых значений,
предполагающихся в реальной форме
вызова этой функции. Например, вызов

[ s1, s2, s3 ] = MatrProc1( x1,
x2, x)

предполагает
получить аж три возвращаемых значения,
в то время как из определения функции
следует, что возвращаемых значений у
этой функции два. Чтобы предупредить
пользователя функции о несовпадении
числа ожидаемых возвращаемых значений
их номинальному числу, нужно в теле
функции осуществить проверку переменной
nargout:

if nargout ~= 2
error(
‘Must be 2 return values’ )
end

Осуществлённые
нами проверки приводят к тому, что
функцию можно вызвать только с правильным
числом входных параметров и возвращаемых
значений. Однако ранее мы встречались
со встроенными функциями системы MATLAB,
которые могли быть вызваны с разным
числом входных параметров (и это очень
типично). В результате фактически разные
работы бликого типа выполняются под
одним и тем же именем функции, что весьма
наглядно и удобно. Таковой, например,
является функция plot,
имя которой
говорит о построении графиков функций.
Если бы разные варианты вызовов этой
функции пришлось бы осуществлять под
разными именами, то от наглядности не
осталось бы и следа.

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

function
[ res1, res2] = TestFunc2( var1, var2 )

switch
nargin

case
1

if
nargout == 1, res1 = var1 * 2;

elseif
nargout == 2, res1 = var1 * 2; res2 = var1 + 3;

else
error( ‘Must be 1 or 2 return values’ );

end

case
2

if
nargout == 1, res1 = var1 .* var2;

elseif
nargout == 2, res1 = var1 .* var2; res2 = var1 + 3;

else
error( ‘Must be 1 or 2 return values’ );

end

otherwise
error( ‘Must be 1 or 2 parameters’ );

end

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

В
заключение отметим, что степень
подробности проверок зависит от
предназначения функции. Если M-функция
пишется для собственного потребления,
проверки могут быть менее строгими. Но
если предполагается передача функции
для внешнего потребления, то проверки
нужно сделать более жёсткими, так как
внешнему пользователю трудно разобраться
во всех деталях работы вашей функции.

5.
Видимость имён переменных и имён функций.
Локальные и глобальные переменные.
Функция
располагает собственным, изолированным
от рабочего пространства системы MATLAB,
пространством переменных. Поэтому, если
перед вызовом M-функции
в командном окне MATLABа
была определена переменная с именем,
например, varName1,
то
нельзя рассчитывать на то, что переменная
в теле функции с этим же именем уже имеет
некоторое значение. Это совсем другая
переменная (хотя у неё и то же самое имя
varName1)
и располагается она в памяти машины в
другой области памяти.

Переменные,
которые используются в теле M-функции
и не совпадают с именами формальных
параметров этой функции, называются
локальными.
По-другому говорят, что они видимы лишь
в пределах M-функции.
Извне они не видны (не достижимы). Внутри
функции не видны переменные, определённые
в командном окне MATLABа
— они являются внешними по отношению к
функции и не видны в ней.

Аналогично,
локальные внутри некоторой функции
переменные не видны внутри другой
M-функции.

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

Чтобы
рабочая область системы MATLAB
и несколько M-функций
могли совместно использовать переменную
с некоторым именем, её всюду нужно
объявить как глобальную с помощью
ключевого слова global.
К примеру,
переменная glVarS,
участвующая
в вычислениях в рабочем пространстве
и в функции FuncWithGlobVar
является
одной и той же переменной (единственный
участок памяти) повсюду —
поэтому её можно использовать в функции
без дополнительного присваивания её
какого-либо значения:

Т
ак
как у глобальных переменных «глобальная»
область
действия, то чтобы случайно (по ошибке)
не переопределить её где-либо, желательно
давать таким переменным более мнемонические
(более длинные и осмысленные) имена.

Теперь
рассмотрим вопрос о видимости имён
функций. Если мы сохранили функцию с
некоторым именем в файле с этим же именем
и расширением m,
и кроме
того если системе MATLAB
известен
путь к этому файлу на диске, то эту
функцию можно вызывать как из командного
окна, так и из других функций.

Однако
в тексте M-функции
можно поместить опеределения нескольких
функций, причём только одна из них может
совпадать по имени с именем файла. Именно
эта функция и будет видна из командного
окна и других функций. Все остальные
функции будут внутренними — их могут
вызывать только функции из того же
файла.

Например,
если в файле ManyFunc.m
будет
содержаться следующий текст

function
ret1 = ManyFunc( x1, x2 )

ret1
= x1 .* x2 + AnotherFunc( x1 )

function
ret2 = AnotherFunc( y )

ret2
= y .* y + 2 * y + 3;

состоящий
из определений двух функций с именами
ManyFunc
и
AnotherFunc,
то
извне можно вызывать только функцию
ManyFunc.
По-другому
можно сказать, что извне видны только
функции с именами, совпадающими с именами
M-файлов.
Остальные функции должны вызываться
этой функцией и другими внутренними
функциями.

6.
Разработка и отладка M-функций.
Разрабатывая функцию, вы в первую очередь
разрабатываете алгоритм решения некторой
задачи, после чего переводите его на
формальный язык кодирования, которым
и является M-язык.
Несмотря на довольно высокую наглядность
M-языка
(отсутствуют низкоуровневые конструкции,
близкие к машинным командам), всё равно
это формальный язык. По прошествии
времени детали разработок забудутся и
для модификации функции придётся всё
вспоминать снова.

Чтобы упростить
процесс дальнейшей модификации функции,
а также её отладки на стадии, когда ещё
не удалось добиться правильной работы,
в текст функции вставляют комментарии.

Комментарии
могут занимать отдельные строки,
начинающиеся с символа %, после которого
следует текст комментария. Также
комментарии можно располагать в конце
любой строки кода, поскольку интерпретатор
M-языка,
встретив знак %, считает все символы
после него просто комментарием (а не
командами, подлежащими переводу в
машинную форму и исполнению).

Особую
роль в системе MATLAB
имеют комментарии, располагающиеся в
смежном наборе строк сразу за заголовком
определения функции. Весь этот набор
строк выводится в командное окно системы
MATLAB
при исполнении команды

help
имя_M-функции

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

Теперь
подробно остановимся на вопросе об
отладке M-функций,
то есть на приёмах, с помощью которых
можно выявить месторасположение ошибок
и их причину. Система MATLAB
осуществляет серьёзную помощь в этом
процессе. В частности, при возникновении
ошибки в процессе выполнения M-функции,
в командное окно выводится приблизительное
диагностическое сообщение (не следует
переоценивать качество такой диагностики)
и номер строки, в котором по мнению
MATLABа
произошла ошибка.

Другим,
более развитым способом отладки функции
является применение точек останова и
пошаговое выполнения тела функции. Для
этого применяют встроенные возможности
редактора-отладчика системы MATLAB.
То, что уже
многократно применяемый нами редактор
(в нём набираем текст функций и с помощью
меню сохраняем в файле) заодно является
и отладчиком, говорит даже заголовок
его окна:

Matlab
Editor / Debugger

так
как debugger
в переводе
с английского означает «отладчик».

Чтобы
поставить «точку
останова»
на какой-либо строке кода функции, туда
нужно поместить курсор и нажать клавишу
F12
(повторное
нажатие этой клавиши убирает точку
останова). Вместо нажатия этой клавиши
можно выполнить команду меню

Debug
| Set/Clear Breakpoint

но
всё же быстрее это можно выполнить
нажатием клавиши. После этого в строке
слева появляется красный кружок,
указывающий на то, что в данной строке
проставлена точка останова. После этого,
не закрывая окна Редактора/Отладчика
(Editor/Debugger),
переключаем
фокус ввода с клавиатуры в командное
окно MATLABа
и запускаем обычным образом функцию на
выполнение. После этого и произойдёт
останов выполнения функции прямо на
строке, в которой поставлена точка
останова (Breakpoint).

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

Далее,
нажимая клавишу F10
мы можем выполнять функцию построчно,
каждый раз проверяя результаты такой
пошаговой работы функции. В результате
всегда можно «окружить
ошибку»
и выявить её причину.

Изменив текст
функции и устранив выявленную
ошибку,запускаем функцию на выполнение,
в результате чего либо удостовериваемся
в её правильной работе, либо находим
новую ошибку. Желательно продумать
методику отладки, запуская функцию на
выполнение с разными значениями
аргументов и разными значениями
глобальных функций. В результате такого
итерационнного отладочного процесса
приходят к правильно работающим функциям.

7.
Массивы символов.
До сих пор мы
мели дело с единственным типом данных
— массивами вещественных чисел. Это
действительно основной тип данных
системы MATLAB,
предназначенный для вычислений. В то
же время, при рассмотрении графики
MATLABа
мы столкнулись с типом данных «короткое
целое«,
обозначаемое с помощью ключевого слова
uint8.
Этот тип
данных специально предназначен для
компактного хранения больших массивов
целых чисел, что очень характерно для
графических задач. Однако производить
вычисления с типом данных uint8
нельзя (по
крайней мере в версии системы MATLAB
5.2). Если всё же нужно произвести
вычисления, то сначала тип данных uint8
приводят
явно к типу double,
производят вычисления и возвращаются
к типу uint8
для
дальнейшего хранения.

Во
всех языках программирования, и MATLAB
здесь не исключение, большую роль играет
обработка текстовых данных. Для этой
цели в системе MATLAB
предусмотрен тип данных char
(то есть
«символ»).
Текстовые
данные, в том числе и одиночный символ,
должны заключаться с обеих сторон
апострофами:

c1
= ‘a’; c2 = ‘abcd’; c3 = ‘Hello, World!’;

В

результате таких присваиваний создаются
переменные (естественно, это массивы —
в системе MATLAB
всё является массивами) типа char:

Из
рисунка видно, что текстовые данные в
системе MATLAB
являются вектор-строками типа char
(одна строка
и несколько столбцов по числу содержащихся
символов). Например, переменная c3
является
символьным массивом (часто говорят —
строкой символов) из 13 символов, занимающим
26 байт. Таким образом, под каждый символ
отводится 2 байта.
Каждый
символ кодируется целым числом в
соответствии со стандартной системой
кодировки ASCII.
Легко
практически выяснить,
какой код
соответствует тому или иному символу.
Следующий фрагмент

code
= double( c1( 1 ) )

code
=

97

показывает,
что символу ‘a’
соответствует
десятичное число 97.

Если
после того, как переменная c3
получила
текстовое значение ‘Hello,
World!’, написать

c3
= 3.14;

то
переменная c3
станет уже
переменной типа double.
Так как в
сложных и громоздких M-функциях
могут возникнуть ситуации, когда заранее
неизвестен тип переменной в какой-либо
момент времени исполнения функции, то
с целью определения типа переменной
следует применить функцию isa.
Например,
следующий вызов этой функции

isa(
s3, ‘char’ )

вернёт
истину (единицу), если переменная s3
является в этот момент строковой
(символьной), и вернёт ложь (нуль) в
противоположном случае.

По
отношению к массивам символов справедливы
также все операции, которые мы ранее
рассмотрели для случая массивов типа
double.
Например,
вместо группового присваивания
c2
= ‘abcd’
можно
организовать поэлементное присваивание
с помощью операции индексации:

c2(
1 )=’a’; c2( 2 )=’b’; c2( 3 )=’c’; c2( 4 )=’d’;

или осуществить
операцию конкатенации

c2
= [ ‘abc’ , ‘d’ ]; c2 = [ c2 , ‘ QWERTY’ ];

В
тесной связи с рассмотренной операцией
конкатенации текстовых строк находится
стандартная функция int2str,
которая
преобразует целые числовые значения в
символы, отображающие эти целые числа.
Например, вызов функции

res
= int2str( 2 )

приведёт
к появлению текстовой переменной res
со значением
‘2’.
В итоге, мы имеем возможность сформировать
в цикле набор нескольких имён функций,
отличающихся только последним символов
— их номером:

name
= ‘function’; arg = 10.7;

for
k = 1 : 10

Name
= [ name , int2str( k ) ];

res(
k ) = feval( Name, arg );

end

и
даже вычислить значения всех таких
функций при значении аргумента
arg.
Это
осуществляется с помощью стандартной
функции системы MATLAB
feval,
которая
принимает в качестве своего первого
аргумента текстовую строку с именем
M-функции,
подлежащей вычислению. Второй и
последующие аргументы этой функции
служат для передачи в качестве аргументов
вычисляемым функциям.

В
вышеприведённом фрагменте результаты
вычислений десяти функций запоминаются
в массиве res.

Если
требуется в одной переменной запомнить
несколько имён функций (это возможно в
случае их одинаковой длины) для
последующего их исполнения с помощью
feval,
то можно
сформировать текстовый массив размерности
2:

Names(
1, : ) = ‘function1’;

Names(
2, :
) = ‘function2’;

Первая
строка этого массива содержит имя первой
функции, вторая строка — второй функции.
Размер этого массива типа char
есть 2
x 9.

Часто
текстовые строки используются для
вывода в командное окно системы MATLAB
для информирования пользователя о ходе
выполнения M-функции.
Это осуществляется с помощью функции
disp,
принимающей
в качестве аргумента текстовую строку:

x
= 7;

message
= [ ‘ Variable x = ‘, int2str( x ) ];

disp(
message );

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

VarX
= input( ‘ VarX = ? ‘ );

Функция
input
выводит в
командное окно текст, являющийся её
аргументом, после чего ожидает ввода
значения с клавиатуры и нажатия клавиши
Enter.
Таким
образом можно ввести с клавиатуры
числовое значение и запомнить её значение
в переменной VarX.
Внутри
строки-аргумента функции input
может
присутствовать специальный набор из
двух символов /n,
приводящий
к показу сообщения на двух строках
(часть сообщения после
/n
показывается
на новой строке ).

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

VarStr
= input( ‘ StringVar = ‘, ‘s’ );

В результате
выполнения этой функции на экране
появляется надпись

StringVar
=

после
чего можно набирать необходимый текст
с клавиатуры, заканчивая ввод нажатием
клавиши Enter.
Если нажать
Enter,
не введя
с клавиатуры никакого текста, то
переменная VarStr
примет
значение пустого массива. Желательно
перед использованием этой переменной
проверять её на этот случай функцией
isempty(VarStr),
возвращающей
единицу, когда аргумент является пустым
массивом.

Система
MATLAB
располагает также полным набором функций
для «классической»
обработки
текстов. К таким функциям относятся
функции findstr,
blanks,
deblank,
num2str,
str2num, strcat, strcmp, strcmpi, strrep, strtok.

Функции
num2str,
str2num
производят
преобразования из строк в действительные
числа и обратно, функции blanks,
deblank,
strrep
работают
с пробелами и повторением символов,
функция strcat
осуществляет
конкатенацию, функции strcmp
и
strcmpi
сравнивают значения двух строк, функции
findstr
и
strtok
находят
или выделяют в строках подстроки.

Например,
в следующем фрагменте находится массив
позиций вхождения слова Hello в
текст, содержащийся в переменной vStr:

innerStr
= ‘Hello’;

vStr=’Hello
is the word. Hello is opposite to bye.’;

positions
= findstr( vStr, innerStr );

В
результате переменная (масси ) positions
принимает
следующее значение:

positions
=

1
20

В
итоге функция findstr
обнаружила
два вхождения переменной
innerStr
в текст Vstr.
Первое
вхождение имеет место начиная с самого
первого символа, второе вхождение имеет
место на 20-ом символе (включая пробелы,
разумеется).

Если
функция findstr
не находит вхождений вообще, то она
возвращает пустой массив, который надо
проверять функцией isempty.

8.
Массивы структур.
Бывает желательно под одним именем
объединить числовые и текстовые данные
(например, результаты физических
экспериментов, данные о
переписи
населения и так далее). Для этой цели в
системе MATLAB
предусмотрен
специальный тип данных — struct
( структура
).

Переменные
типа struct
имеют в
своём составе несколько именованных
полей. Создадим переменную MyStruct1,
состоящую
из двух полей:
одного числового поля с именем data
и одного
текстового поля с именем name:

MyStruct1.name
= ‘1st result’;

MyStruct1.data
= [ 1, 2.5; -7.8, 2.3 ];

Имя
поля отделяется от имени переменной
точкой. В данном фрагменте кода создаётся
массив MyStruct1
типа
struct
размером
1
x 1.

Добавим
в только что созданный массив MyStruct1
второй
элемент:

MyStruct1(
2 ).name = ‘2nd res-t’;

MyStruct1(
2 ).data = [ -5.7, -2.5; 7.1, 8.4 ];

Получился
массив размера 1×2.
В этом
легко убедиться, если набрать в командном
окне MATLABа
имя переменной
MyStruct1
и нажать
клавишу Enter.
В результате система
покажет не содержимое этого массива, а
его структуру:

Можно
и далее добавлять элементы к этому
одномерному массиву. Достаточно очевидно,
что все элементы массива типа struct
имеют
одинаковое количество полей с
фиксированными именами. Если явно не
задать значение какого-либо поля, то
ему автоматически будет присвоен пустой
массив [].

Набор
полей массива структур можно изменять
динамически. Например, уже после того,
как мы определили массив MyStruct1
типа struct
размера
1×2
с двумя
указанными выше полями (name
и data),
можно
выполнить присваивание

MyStruct1(
1 ).field = ‘Third field’;

после
которого массив структур уже будет
обладать тремя полями
— name,
data
и field.
Так как у
второго элемента массива MyStruct1
поле field
явно не
задано, то оно равно пустому массиву:

MyStruct1(
2 ).field

ans
=

[]

Если
два массива структур имеют одинаковый
набор полей, то допускается групповое
присваивание вида

MyStruct1(
3 ) = AnotherStruct( 2 );

когда
значения всех полей второго элемента
массива AnotherStruct
копируются
в поля третьего элемента массива
MyStruct1.

Если
работа ведётся в интерактивном режиме,
когда все данные вводятся с клавиатуры,
рассмотренный процесс последовательного
задания полей и элементов массива
структур вполне оправдан. Однако в
программном режиме он не достаточно
хорош с точки зрения производительности.
Вместо него лучше использовать функцию
с именем struct:

MyStruct2
= struct( ‘field1′,[ 1 2 3],’field2′,’Hello’);

MyStruct2(2)=
struct( ‘field1′,[ 7 8 9],’field2′,’World’);

Покажем
теперь (хотя это и очевидно), как
подобраться к единственному числовому
значению в поле data
первого
элемента массивы MyStruct1.
Для этого
надо применить две операции индексации
и одну операцию доступа к полю структуры.
Например,
выражение

MyStruct1(
1 ).data( 1 , 2 )

имеет
значение 2.5,
так как в поле data
расположены числовые матрицы 2×2.

Если
же требуется групповая операция
копирования содержимого одноимённого
поля всех элементов массива структур,
то здесь решение менее очевидно:

v
= [ MyStruct1.data ];

Применение
прямоугольных скобок обязательно, так
как над значениями полей отдельных
элементов производится операция
конкатенации, которая в системе MATLAB
и обозначается прямоугольными скобками.
В результате такой операции переменная
v
становится
матрицей 2×4
(
если учесть ранее введённые значения
).

Для
удаления некоторого поля из всех
элементов созданного массива структур
применяют функцию rmfield:

MyStruct2=rmfield(MyStruct2,’field2′);

После
этого в массиве структур MyStruct2
остаётся
только поле field1.

В
качестве содержимого некоторого поля
структуры может выступать другая
структура, то есть структуры
могут быть вложенными.
В качестве имени вложенной структуры
выступает имя поля объемлющей структуры:

Outer.number
= 1;

Outer.inner.name=’name1′;

Outer.inner.data=[
5 3; 7 8];

Здесь
Outer
— имя внешней
(объемлющей) структуры, а inner
— имя
внутренней структуры, являющейся полем
структуры Outer.
Для чтения
числового данного, стоящего во второй
строке первого столбца (поле data),
применяем выражение

Outer.inner.data(
2, 1 )

M
ATLAB
сообщает, как устроены структуры Outer
и inner
следующим образом:

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

isstruct(
s )
— возвращает
истину, если аргумент структура

isfield(
s, ‘name’)
— возвращает
истину, если имеется такое поле

fieldnames(
s )
— возвращает
массив строк с именами всех полей

Структуры
MATLABа
можно
назвать агрегированным
типом данных.
Другим агрегированным типом данных в
системе MATLAB
являются так называемые ячейки
(cells).

9.
Массивы
ячеек.
Массив ячеек
может
содержать в качестве элементов массивы
разных типов! Таким образом, он является
универсальным контейнером — его ячейки
могут содержать любые типы и структуры
данных, с которыми работает MATLAB
— массивы
чисел любой размерности, строки, массивы
структур и другие (вложенные) массивы
ячеек. Массив ячеек может быть полем
структуры.

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

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

MyStruct
= struct( ‘field1′,[ 1 2 3],’field2′,’Hello’);

MyCellArray(
1, 1 ) = { ‘Bonjour!’ };

MyCellArray(
1, 2 ) = { [ 1 2 3; 4 5 6; 7 8 9 ] };

MyCellArray(
2, 1 ) = { MyStruct };

MyCellArray(
2, 2 ) = { [ 9 7 5 ] };

с
троится
массив ячеек 2×2,
элементами которого являются ячейки,
содержащие соответственно текстовую
строку, числовой массив 3×3,
структуру
MyStruct
и вектор-строку 1×3.
Итак,
построенный массив ячеек содержит
разнородные данные, о чём нам и сообщает
система MATLAB
при вводе имени такого массива и нажатии
клавиши Enter:

При
этом показывается содержимое не всех
ячеек этого массива. Более подробную
информацию можно получить, вызвав
функцию
celldisp(MyCellArray):

MyCellArray{1,1}
=

Bonjour!

MyCellArray{2,1}
=

field1
: [ 1 2 3 ]

field2
: ‘Hello’

MyCellArray{1,2}
=

1
2 3

4
5 6

7
8 9

MyCellArray{2,2}
=

9
7 5

Отсюда видно, что
для того, чтобы подобраться к содержимому
ячеек, нужно индексировать массив ячеек
при помощи фигурных скобок. При обычной
индексации круглыми скобками мы из
массива ячеек извлекаем отдельную
ячейку. Напоминаем ещё раз о том, что
следует чётко различать саму ячейку и
её содержимое (см. выше).

Массивы
ячеек полностью решают типовую задачу
хранения нескольких строковых данных
под одним именем. Раньше мы уже формировали
матрицы типа char,
каждая
строка которых имела одну и ту же длину.
Это очевидным образом ограничивает
применение такого решения. В случае
массива ячеек такого ограничения нет:

cellNames{
1 } = ‘function1’;

cellNames{
2 }
= ‘func2’;

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

disp(
cellNames{ 1 } ); disp( cellNames{ 2 } );

Как
и в случае структур, показанное выше
поэлементное создание массива ячеек
неэффективно с точки зрения
производительности. Это не создаёт
проблем в медленном интерактивном
режиме работы, но в программном режиме
этот процесс лучше предварить вызовом
функции cell():

MyCellArray
= cell( 2, 2 );

которая
сразу создаст массив ячеек требуемой
размерности и размера, причём каждая
ячейка будет пустой. Пустые ячейки
обозначаются как {[]}.
Затем можно
осуществлять ранее рассмотренные
поэлементные присваивания, так как
теперь они не требуют перестройки
структуры массива с каждым новым
присваиванием.

Содержимым
пустой ячейки является пустой числовой
массив, который, как мы знаем, обозначается
[].
Чтобы
удалить некоторый диапазон ячеек из
массива ячеек, нужно этому диапазону
присвоить значение пустого массива []:

MyCellArray(
2, : ) = [];

Теперь
массив ячеек MyCellArray
имеет
размер 1×2,
так как мы только что удалили всю вторую
строку массива.

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

В
определении M-функции
параметр, через который передаётся
заранее неизвестное число входных
аргументов, нужно обозначить ключевым
словом varargin.
Им
обозначается массив ячеек, в который
упакованы эти параметры. Функция всегда
может узнать истинное число аргументов
в этом параметре, вычислив функцию
length.
Ниже представлен код функции, вычисляющей
сумму квадратов
длин
вектор-строк:

function
sumlen = NumLength( varargin )

n=
length( varargin ); sumlen = 0;

for
k = 1 : n

sumlen
= sumlen + varargin{ k }(1)^2 +varargin{ k }(2)^2;

end

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

При
вызове функции NumLength
не нужно (и нельзя) упаковывать входные
числовые вектор-строки в массив ячеек,
так как MATLAB
делает это сам. Достаточно перечислить
их в качестве фактических параметров
через запятую:

NumLength(
[ 1 2], [3 4] )

ans
=

30

Теперь
вызовем функцию
NumLength
с другим
числом параметров:

NumLength(
[ 1 2], [3 4], [ 5 6] )

ans
=

91

Функция легко
обрабатывает оба этих случая.

Использование
массивов ячеек для передачи M-функциям
произвольного числа параметров (или
для возвращения функцией произвольного
числа выходных значений) является
единственно возвожным решением проблемы.
Существуют ещё и другие случаи, когда
обязательно требуется применение
массива ячеек. О них будет рассказано
в следующей главе. А сейчас ещё упомянем
удобный способ заменить список величин,
разделённых запятыми, компактным
индексным выражением с массивом ячеек.

Таким
заменителем является индексное выражение,
извлекающее содержимое диапазона ячеек
из массива ячеек. Для примера рассмотрим
функцию plot(),
которая
изучалась нами в главе, посвящённой
построению графиков функций. Этой
функции в качестве параметров передаются
массив значений независимой переменной,
массив значений зависимой переменной
и текстовая строка, управляющая внешним
видом графика. Для компактности все эти
переменные (массивы) можно упаковать в
массив ячеек, например,

F(
1 ) = { 0 : 0.1 : pi };

F(
2 ) = { sin( F{1} ) };

F(
3 ) = { ‘bo:’ };

Теперь
вся информация, необходимая для построения
графика функции сосредоточена в
единственной переменной F.
Построение
графика функции можно осуществить с
помощью компактного выражения

plot(
F{ 1 : 3 } )

так
как операция взятия содержимого диапазона
ячеек с точки зрения системы MATLAB
порождает
список величин, разделённых запятыми.

10.
Чтение и запись файлов данных.
Ранее были
рассмотрены MAT-файлы,
в которых сохраняются переменные из
рабочей области системы MATLAB.
Также были
рассмотрены M-файлы,
хранящие текст M-функций.
Теперь рассмотрим файлы произвольного
формата, в которых M-функции
могут записывать, а затем читать
собственные данные.

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

Начнём
с числовых векторов и матриц. Работать
будем с так называемыми бинарными (не
текстовыми) файлами, которые сначала
надо открыть с помощью предназначенной
для этого функцией fopen
системы
MATLAB:

fid
= fopen( ‘имя-файла’,
‘флаг’
)

где
имя файла может предваряться полным
путём к нему (иначе файл должен
располагаться в текущем каталоге
MATLABа).
Второй параметр этой функции — так
называемый флаг открытия файла, говорит
о способе дальнейшей работы с файлом:

‘rb’
— только
для чтения

‘wb’
— только
для записи
(предыдущее
содержимое теряется)

Вторая
буква в этих примерах говорит о бинарном
характере файлов. Возможен ещё флаг,
разрешающий как чтение, так и запись
файлов одновременно (
‘r+’
), но
мы его здесь использовать не будем.

Функция
fopen
возвращает числовой идентификатор
открытого файла, который надо использовать
в качестве параметра для функций чтения
и записи в этот файл. Если операция
открытия файла не удалась (это возможно
как по причине отсутствия файла, так и
по причине неправильного указания пути
к нему на диске), то функция fopen
возвращает
-1.

Всегда
следует проверять возврат функции
fopen:

fid
= fopen( ‘имя_файла’,
‘флаг’
);

if(
fid == -1 )

error(
‘File is not opened’ )

end

После
того, как файл больше не требуется, его
следует закрыть функцией fclose:

fclose(
fid )

Чтение
и запись информации в бинарные файлы
осуществляется функциями fread
и fwrite.
Функция fwrite,
предназначенная для записи информации
в файлы, имеет следующие аргументы:

fwrite(
fid, A, ‘precision’ )

где
fid
— файловый
идентификатор, возвращаемый функцией
fopen;
A — вектор
или матрица, чьи элементы подлежат
записи в файл;
строка ‘precision’
говорит о
размере памяти, отводимой под вещественные
числа. Это 8 байт или 64 бита, так что
строка должна иметь вид ‘float64’.

В
следующем фрагменте кода создаются
вектор-столбец a
и матрица B
размером
2×3,
которые затем записываются в файл с
именем ‘dataTest.gqw’
(здесь
расширение имени файла выбрано произвольно
так, чтобы не совпасть с известными
расширениями):

a
= [ 1; 2; 3 ]; B = [ 4 5 6; 7 8 9 ];

fid1
= fopen( ‘dataTest.gqw’, ‘wb’ );

fwrite(
fid1, a, ‘float64’ );

fwrite(
fid1, B, ‘float64’ );

fclose(
fid1 );

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

fid1
= fopen( ‘dataTest.gqw’, ‘rb’ );

[
a , count ] = fread( fid1, [1 3], ‘float64’ );

[
B , count ] = fread( fid1, [2 3], ‘float64’ );

fclose(
fid1 );

Легко
убедиться, что прочитанные значения
совпадают с ранее записанными. При этом
число count
равно числу
реально прочитанных вещественных чисел.
При чтении вектора a
это число
будет равно 3, а при чтении матрицы B
— будет
равно 6.

B
=

4
5 6

7
8 9

count
=

6

Последний из приведённых нами фрагментов
кода страдает рядом практических
недостатков, которые ярко высвечивают
проблемы, с которыми приходится
сталкиваться при работе с файлами
(особенно, бинарными). Во-первых, мы лишь
для краткости изложения не применяем
проверку правильности открытия файла,
о которой мы уже говорили выше.

Во-вторых,
при чтении какого-либо данного внутренний
указатель
текущей позиции
(подлежащей чтению) файла
продвигается на число прочитанных байт
информации. В какой-то момент он может
выйти на границу файла, и читать станет
нечего. Такую ситуацию нужно отслеживать,
чтобы не допускать ошибочных действий.
Мы же в данном примере положились на
наше хорошее знание устройства файла,
поэтому мы вначале прочитали вектор, а
затем — матрицу (в другом порядке это
делать нельзя), указав при этом их
правильные размеры.

Для
отслеживания позиции файлового указателя
и работы с ним служат функции feof
(служит
для индикации конца файла), fseek
(устанавливает
файловый указатель), ftell
(позволяет
узнать значение текущего файлового
указателя), frewind
(устанавливает
файловый указатель на началдо файла).
Все эти функции имеют прозрачный смысл,
поэтому мы их подробно не будем
рассматривать. О них всегда можно
разузнать в справочной системе MATLABа.

Теперь
поговорим немного о записи строк. Пока
что мы работали с бинарными файлами.
Другим типом файлов являются текстовые
файлы. Они специально приспособлены
для записи больших фрагментов текста,
поскольку этим файлам органически
присуще «понимание»
деления текста на строки ( в самом что
ни на есть книжном смысле этого слова
), а бинарные файлы этого «не
понимают».
Последние
работают только с потоком байт.

Несмотря
на только что сказанное, текстовые
переменные MATLABа
можно записывать и в бинарные файлы.
Важно только учесть, что каждый символ
требует двух байт, поэтому нужно
использовать флаг ‘int16’.

Вот
пример такой работы:

str1
= ‘Hello’; str2 = ‘World!’;

fid1
= fopen( ‘strTest.gqw’, ‘wb’ );

fwrite(
fid1, str1, ‘int16’ );

fwrite(
fid1, str2, ‘int16’ );

fclose(
fid1 );

В
результате будет создан файл strTest.gqw,
содержащий
в бинарном формате содержимое двух
строковых переменных. Их можно прочесть
с помощью функции fread:

fid1
= fopen( ‘strTest.gqw’, ‘rb’ );

[
a , count ] = fread( fid1, 5, ‘int16’ );

[
b , count ] = fread( fid1, 6, ‘int16’ );

str1
= char( a’ ); str2 = char( b’ );

fclose(
fid1 );

К
прочитанным из файла числовым
вектор-столбцам a
и b
сначала
применяется операция транспонирования
для перевода их в вектор-строки, а затем
осуществляется преобразование к типу
char.

Для
работы со строковыми данными больше
подходят текстовые файлы. Их открывают
с флагами ‘r’
или ‘w’
(букву b,
что означает binary
— двоичный,
теперь добавлять не надо). Писать и
читать строковые переменные в эти файлы
удобно с помощью функций fprintf
и fscanf.
Вот пример
записи в файл:

str1
= ‘Hello’; str2 = ‘World!’;

fid1
= fopen( ‘strTest2.txt’, ‘w’ );

fprintf(
fid1, ‘%srn%srn’, str1, str2 );

fclose(
fid1 );

Одним
вызовом функции fprintf
удаётся
записать сразу две строковые (символьные)
переменные str1
и str2.
Информацию
об этом нужно располагать во втором
параметре функции fprint
в виде символов
формата %s,
означающих
запись строк.
Каждый из
этих символов нужно завершать парой
специальных
символов
rn,
означающих «возврат
каретки и перевод строки».
Таким
образом, каждая из этих двух строк при
чтении файла любым стандартным текстовым
редактором (например, редактором Notepad)
будет
показана на отдельной строке:

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

fid1
= fopen( ‘strTest2.txt’, ‘r’ );

str1
= fgetl( fid1 );

str2
= fgetl( fid1 );

fclose(
fid1 );

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

Никаких
специальных функций для записи и чтения
в файлы структур и массивов ячеек MATLABа
не существует. Поэтому их нужно записывать
поэлементно с последующим поэлементным
чтением и восстановлением их внутреннего
устройства.

---

Matlab M-Files — Introduction

MATLAB allows you to write a series of commands into a file and execute the file as a complete unit, like writing a function and calling it. It is done using M-file.

M-File also called as the script file is a series of MATLAB commands that will get executed sequentially when the file is executed.

The m-file is saved with .m extension.

Program Files

MATLAB allows writing two kinds of program files, which are as follows −

Scripts

Script files are program files with .m extension. In these files, you write a series of commands, which you want to execute together. Scripts do not accept inputs and do not return any outputs. They operate on data in the workspace.

A script file looks as follows −

Functions

Function files are also program files with .m extension. Functions can accept inputs and return outputs. Internal variables are local to the function.

A function file looks as follows −

Let us understand how to create and run the m-file in the next chapters.

Matlab M-Files — Create & Save

In this chapter, we will learn how to create and save a M-file. Let us begin by understanding about creating a M-file.

Create M-file

To create m-file, we will make use of MATLAB IDE as shown below. Here IDE refers to an integrated development environment.

Click on New Script highlighted above to open a new script file.

Save M-file

You will get an untitled file. Let us save the file as firstmfile.m.

Click on the save button and it will open a popup, where you can enter the name of the file.

Click on OK to save the file.

Now, you are free to write your commands in the file below −

Matlab M-Files — Run

In the previous chapter, we have seen how to create and save a m-file. Now in this chapter, we will write a simple code and run the same.

Following is the code which will run inside the firstmfile.m

a = 5; b = 7;
c = a + b
d = c + sin(b)
e = 5 * d
f = exp(-d)

This is how it will look inside MATLAB editor −

Click on the Run button as highlighted above to see the result inside the command window as shown below

Matlab M-Files — Functions

A function is a group of statements that together perform a task. In MATLAB, functions are defined in separate files. The name of the file and name of the function should be thesame.

Functions operate on variables within their own workspace, which is also called the local workspace. These functions separate the variables from the workspace which you access at the MATLAB command prompt. This is called the base workspace.

Functions can accept more than one input arguments and may return more than one output arguments.

The syntax of a function statement is as follows −

function [out1,out2, ..., outN] = myfun(in1,in2,in3, ..., inN)

Here out1, out2…outN are output variables. It can be a single variable or comma separated. The variables in1, in2, in3…inN are input variables which can be single variable or comma separated ones. The function in MATLAB starts with the keyword function as shown in the syntax.

While naming your m-file, you should take care that the file name and the function name has to match. You cannot use the name of any built-in function available in MATLAB.

Let us now create a simple function and save it as .m file and run it. In MATLAB, the IDE allows you to select what type of file you want to create as shown below −

Click on the Function, and it will open a new file as shown below −

Now you can update the output variables, the function name and the input variables in the above untitled file and save the file with the same name as the function name.

The name of our function is MaxNumber() and it gives the maximum number from the input value passed.

Now let us run the function to get the output. You can call the function by using MaxNumber(100,50).

Matlab M-Files — Import Data

In this chapter, we will understand how to import data from an existing m-file in MATLAB.

Consider the m-file firstmfile.m. The contents of the file are as follows −

a = 5; b = 7;
c = a + b
d = c + sin(b)
e = 5 * d
f = exp(-d)

When you execute the file, the data variables are available in the workspace, as shown below −

Let us clear the workspace and the command prompt. Hence, we can now import the file and also check the data available.

To clear workspace, the command is clear all.

The workspace is empty now.

Let us clean the command window by using clc command as shown below −

We have an empty command window.

Now, type the m-file name as shown below. It will execute the code inside the file

The workspace is loaded with all the variables that are used inside the file.

You can also check the details of the variables by using the whos command as shown below −

---

Matlab M-Files — Introduction

MATLAB allows you to write a series of commands into a file and execute the file as a complete unit, like writing a function and calling it. It is done using M-file.

M-File also called as the script file is a series of MATLAB commands that will get executed sequentially when the file is executed.

The m-file is saved with .m extension.

Program Files

MATLAB allows writing two kinds of program files, which are as follows −

Scripts

Script files are program files with .m extension. In these files, you write a series of commands, which you want to execute together. Scripts do not accept inputs and do not return any outputs. They operate on data in the workspace.

A script file looks as follows −

Functions

Function files are also program files with .m extension. Functions can accept inputs and return outputs. Internal variables are local to the function.

A function file looks as follows −

Let us understand how to create and run the m-file in the next chapters.

Matlab M-Files — Create & Save

In this chapter, we will learn how to create and save a M-file. Let us begin by understanding about creating a M-file.

Create M-file

To create m-file, we will make use of MATLAB IDE as shown below. Here IDE refers to an integrated development environment.

Click on New Script highlighted above to open a new script file.

Save M-file

You will get an untitled file. Let us save the file as firstmfile.m.

Click on the save button and it will open a popup, where you can enter the name of the file.

Click on OK to save the file.

Now, you are free to write your commands in the file below −

Matlab M-Files — Run

In the previous chapter, we have seen how to create and save a m-file. Now in this chapter, we will write a simple code and run the same.

Following is the code which will run inside the firstmfile.m

a = 5; b = 7;
c = a + b
d = c + sin(b)
e = 5 * d
f = exp(-d)

This is how it will look inside MATLAB editor −

Click on the Run button as highlighted above to see the result inside the command window as shown below

Matlab M-Files — Functions

A function is a group of statements that together perform a task. In MATLAB, functions are defined in separate files. The name of the file and name of the function should be thesame.

Functions operate on variables within their own workspace, which is also called the local workspace. These functions separate the variables from the workspace which you access at the MATLAB command prompt. This is called the base workspace.

Functions can accept more than one input arguments and may return more than one output arguments.

The syntax of a function statement is as follows −

function [out1,out2, ..., outN] = myfun(in1,in2,in3, ..., inN)

Here out1, out2…outN are output variables. It can be a single variable or comma separated. The variables in1, in2, in3…inN are input variables which can be single variable or comma separated ones. The function in MATLAB starts with the keyword function as shown in the syntax.

While naming your m-file, you should take care that the file name and the function name has to match. You cannot use the name of any built-in function available in MATLAB.

Let us now create a simple function and save it as .m file and run it. In MATLAB, the IDE allows you to select what type of file you want to create as shown below −

Click on the Function, and it will open a new file as shown below −

Now you can update the output variables, the function name and the input variables in the above untitled file and save the file with the same name as the function name.

The name of our function is MaxNumber() and it gives the maximum number from the input value passed.

Now let us run the function to get the output. You can call the function by using MaxNumber(100,50).

Matlab M-Files — Import Data

In this chapter, we will understand how to import data from an existing m-file in MATLAB.

Consider the m-file firstmfile.m. The contents of the file are as follows −

a = 5; b = 7;
c = a + b
d = c + sin(b)
e = 5 * d
f = exp(-d)

When you execute the file, the data variables are available in the workspace, as shown below −

Let us clear the workspace and the command prompt. Hence, we can now import the file and also check the data available.

To clear workspace, the command is clear all.

The workspace is empty now.

Let us clean the command window by using clc command as shown below −

We have an empty command window.

Now, type the m-file name as shown below. It will execute the code inside the file

The workspace is loaded with all the variables that are used inside the file.

You can also check the details of the variables by using the whos command as shown below −

02 Структурированная программа и пользовательская функция

2.1 Напишите сценарий Matlab

Прежде всего, вам нужно знать сценарий Matlab:

• Сценарий MATLAB включает в себя строку инструкций MATLAB
• Сценарий должен быть сохранен перед запуском.mВ файле

2.2.1 Создание скрипта

ЩелкнулHOMEсерединаNew ScriptКнопка

В настоящее время появляется коробка редактирования сценария, как показано ниже:

Здесь мы вводим следующий код

for i = 1:10
    x = linspace(0, 10, 101);
    plot(x, sin(x+i))
    print(gcf, '-deps', strcat('plot', num2str(i), '.ps'));
end

ЩелкнулRunВремя выполнения

ЗдесьНазвание сохранения

Затем представьте следующие результаты операции

Примечание:

• Выберите сегмент кода и используйте интеллектуальное отступ (Smart Adent)
• Используйте%для выполнения аннотаций каждой строки
• Используйте %%, чтобы разделить сегмент кода на блок
• Выберите определенный блок, запустите раздел, только выполните код блока
• Запустить (запустить), выполнить весь код

2.2.2 Написание скрипта обычно используется ярлыками

• Ctrl + R: Замечание
• Ctrl + T: Отмена банка отбора
• Ctrl + I: Интеллектуальное отступление банка отбора

2.2 Структурная программа дизайн

2.2.1 Логический оператор

Оператор	иллюстрировать
<	Меньше, чем
<=	Менее чем равен
>	больше, чем
>=	больше или равен
==	Определите, равны ли левая и правая сторона
~=	Определите, не равны ли левая и правая сторона
&&	а также
||	или же

Отличается от других языков: matlab не означает использование~=выражать

2.2.2 Предложение управления потоком

Порядок выполнения кода MatlabСверху внизЕсли вы хотите внедрить некоторые неуказанные структуры, вам нужноОператор управления потоком

Оператор управления потоком	иллюстрировать
if，elseif，else	Условие состоит в том, чтобы выполнить оператор, когда истина
for	Цикл является специфическим, и каждая итерация отслеживается через увеличенную переменную индекса
switch，case，otherwise	Выполните группу нескольких наборов предложений
try，catch	Выполнить операторы и ошибки захвата
while	Заявление цикла, условия все еще переносятся истинными
break	Прекратить выполнение цикла для или во время и заканчивайте всю итерацию цикла
continue	Завершить этот раунд цикла ирации, и в следующий раз, когда это будет сделано обычно
end	Завершите блок предложения, образуйте блок, отличите его от других блоков
pause	Прохождение выполнения программы
return	Вернуться к сценарию или функции вызова

if elseif else

Формат грамматики:

Если условие 1
 Заявление 1
 Elseif Условие 2
 Заявление 2
else
 Предложение 3
end

2.3 Пользовательская пользовательская функция