Символьная переменная в М-файле: 

str=’P I Pupkin’

ее символьное содержимое заключается в кавычки.

Ввод:

xleft=input('введите левую границу интервала поиска ');

Вывод:

disp('ВВОД ИСХОДНЫХ ДАННЫХ края диапазона поиска, точность по аргументу ИЛИ по функции ');

disp(string);

Рис. 1.4. Описание функции в М-файле

В общем виде обращение к функции

[n1, n2, …, n10]=funName(v1, v2, …, v4)

где в квадратных скобках необязательный список возвращаемых значений (то есть имена переменных которым будут присвоены соответствующие значения). Если их не указывать то МАТЛАБ сам создаст какие-то переменные и присвоит им эти значения.

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

В М-файле описание функции начинается с слова function как в примере

function [x,y,xleft1,xright1,nn]=ZolS1()

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

Ее вызов в тексте М-файла (в том месте программы где функция вызвана она исполняется)

[x,y,xleft1,xright1,nn]=ZolS1();   

Сохранение File—Save при этом откроется окно (рис.1.5), в котором надо будет указать где и под каким именем хотите сохранить этот М-файл.

Рис. 1.5. Сохранение М-файла

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

Если какие-то М-файлы уже созданы ранее то их можно посмотреть командой File—Open и выбрать тот который нужен.

Для рассмотрения простейших операций ввода/вывода и текстовых комментариев целесообразно создать m-файл в виде скрипта с именем Kvadr2S: Для ввода 3-х коэффициентов квадратного уравнения a*x^2+b*x+c=0 служат 3 оператора: a=input('a='); b=input('b='); c=input('c='). В результате в командных строках последовательно появятся надписи:

a=

b=

c=,

куда следует записать конкретные значения коэффициентов a,b,c.

Команда clc стирает все предыдущие записи в командных строках Command Window.

clc; disp ('Программа Kvadr2S '); disp ('ОПР.-Е КОРНЕЙ КВ. УР.-Я'); disp ('ИСХОДНЫЕ ДАННЫЕ'); disp ('Коэф.- ты ур.- я a*x^2+b*x+c=0') a=input('a='); b=input('b='); c=input('c='); %вычисление детерминанта det=b^2-4*a*c; %вычисление двух корней x1=(-b-sqrt(det))/2/a;  x2=(-b+sqrt(det))/2/a;  disp ('РЕЗУЛЬТАТЫ РАСЧЕТОВ') if det<0 ss='Получены комплексные корни'; else ss='Получены вещественные корни'; end  disp (ss);  s0='Детерминант уравнения = '; disp(sprintf('%s %d',s0,det)); disp ('Корни уравнения'); if det<0 disp('x1='); disp(x1); disp('x2='); disp(x2);  else  disp(sprintf('x1=%g x2=%e',x1,x2));  end

Оператор вывода disp (x) служит для вывода в рабочую область Command Window чисел и переменных – первые четыре оператора disp программы выводят символьные переменные, заключенные в кавычки, которые характеризуют решаемую задачу - в данном случае это определение корней квадратного уравнения.

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

                                                                   ставится знак процента (%):

%вычисление детерминанта

det=b^2-4*a*c;

%вычисление двух корней

x1=(-b-sqrt(det))/2/a;

 x2=(-b+sqrt(det))/2/a;

В конце программы с применением условного оператора if представлены два варианта вывода в рабочую область Command Window  корней уравнения x1 и x2, в зависимости от того являются ли они вещественными (det>=0) или комплексными (det<0):

А) Если корни комплексно сопряженные, то запись вывода выполняется в 4 строки:

if det<0

disp('x1=');

disp(x1);

disp('x2=');

disp(x2);

и для коэффициентов a =2; b =3; c =4 результаты также выводятся в 4 строки в виде:

x1=

-0.7500 - 1.1990i

x2=

-0.7500 + 1.1990i

Б) Если корни вещественные, то запись вывода выполняется в 1 строку:

else

       disp(sprintf('x1=%g x2=%e',x1,x2));

 end

Функция sprintf ('x1=%g x2=%e',x1,x2)указывает на то, список выводимых переменных x 1, x 2 будет выводиться в одну строку, с обозначениями и форматами (представлены после знака процент %), приведенными в кавычках.

В данном случае для х1 обозначение будет x1=, а формат g –после обозначения %, а для x2 обозначение будет x2=, а формат e –после обозначения %.

Ниже приведены 5 символов управления форматированием (d – десятичная цифра, а e –представление числа в виде: 10 в степени):

d – десятичное целое со знаком

f – значение со знаком вида [-]dddd.dddd;

e – значение со знаком вида [-]d.dddd e [+|-]ddd;

g – значение со знаком типа e или f в зависимости от значения или точности

s – строка символов.

Форматирование s и f используется при записи вывода значения детерминанта квадратного уравнения:

s0='Детерминант уравнения = ';

disp(sprintf('%s %d',s0,det));

В результате получается вывод значений символьной переменной (s 0) и детерминанта квадратного уравнения (det) для коэффициентов a =2; b =3; c =4 получается в одну строку:

Детерминант уравнения = 23.000000,

а для коэффициентов  - a =1; b =7; c =1:

Детерминант уравнения = 45.000000

Для последних коэффициентов (a =1; b =7; c =1) корни уравнения, выводимые в одну строку с использованием оператора:

disp(sprintf('x1=%g x2=%e',x1,x2));

 получаются в виде:

x1=-6.8541 x2=-1.458980e-001

Следует отметить, что эту же программу можно оформить в виде двух программных модулей:

· Функции без параметров Kvadr2 F. m, которая является головной и используется для ввода данных и вывода результатов, а также обращения к функции с параметрами func_kvadr_ur. m

· Функции с параметрами Function[x1,x2]= func_kvadr_ur (a,b,c), в которой вычисляются корни квадратного уравнения с произвольными коэффициентами a,b,c.

Ниже приведены коды этих двух m-файлов:

%Функция без параметров %Kvadr2 F. m

%Функция с параметрами %func _ kvadr _ ur. m

function [ ] = Kvadr2F() clc; global det; disp ('ОПР.-Е КОРНЕЙ КВ. УР.- Я'); disp ('ИСХОДНЫЕ ДАННЫЕ'); disp ('К.-ты ур.-я   a*x^2+b*x+c=0') a=input('a='); b=input('b='); c=input('c='); [x1,x2] = func_kvadr_ur(a,b,c);  disp ('РЕЗУЛЬТАТЫ РАСЧЕТОВ') if det<0 ss='Получены комп.-е корни'; else ss='Получены веществ.-е корни'; end  disp (ss);  s0='Детерминант уравнения = '; disp(sprintf('%s %f',s0,det)); disp ('Корни уравнения'); if det<0 disp('x1='); disp(x1); disp('x2='); disp(x2);  else disp(sprintf('x1=%g x2=%e',x1,x2));  end  end

function [x1,x2]=func_kvadr_ur(a,b,c) global det; %вычисление детерминанта det=b^2-4*a*c; %вычисление двух корней x1=(-b-sqrt(det))/2/a;  x2=(-b+sqrt(det))/2/a; end

Декларация global det; используется в обоих программных модулях, так как вычисленные значения детерминанта в файле func _ kvadr _ ur. m необходимы для вывода этой величины в файле Kvadr2 F. m.

В заключении этого раздела следует отметить, что встроенная функция MATLAB roots (p), где p =[ a, b, c ] -- последовательность коэффициентов уравнения многочлена (в данном случае квадратного, т.е. второй степени), может решить рассмотренную выше задачу следующим образом в рабочей области Command Window:

для вещественных корней:	для комплексных корней:
>> a=1;b=7;c=1; >> p=[a,b,c]; >> result=roots(p) result = -6.8541 -0.1459	>> result=roots([2,3,4]) result = -0.7500 + 1.1990i -0.7500 - 1.1990i

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

Следует отметить две особенности M -языка программирования:

а) для определения (декларирования) новой переменной ей необходимо присвоить значение, причем любая переменная в MATLAB является матрицей (в простейшем случае эта матрица состоит из одной строки и одного столбца):

function Start_1 aperemenaya=3.4 amatrica(2,3)=0 amatrica(1,2)=9 z=roots([1,4,5,9,-10]) end результаты в Command Window aperemenaya = 3.4000 amatrica = 0 0 0 0 0 0 amatrica = 0 9 0 0 0   0 z = -3.5326 -0.5758 + 1.9507i -0.5758 - 1.9507i 0.6843

б) методы вычислительной математики оформлены в виде стандартных функций расчетов, для применения которых в тексте программы к ним надо обратиться с конкретными фактическими значениями аргументов. Например, для определения всех корней уравнений многочленов произвольной степени необходимо обратиться к функции roots следующим образом: z = roots ([1,4,5,9,-10])

Здесь в круглых и квадратных скобках указываются 5 коэффициентов уравнения многочлена 4-ой степени следующего вида:

1*x^4+4*x^3+5*x^2+9*x-10=0:

M -программу необходимо написать в соответствующем редакторе (Editor) М-файлов. Редактор (Editor) можно открыть так: File--New--M-file.

После того как программа готова ее сохраняют (File—Save as). Причем сохранить надо обязательно именно с тем именем файла, которое не отличается (полностью по буквам совпадает) с именем функции, описанной в программе.

При написании программы ее следует оформлять как описание функции, имеющей список исходных аргументов (их значения передаются в функцию и должны быть определены до ее вызова), а также список возвращаемых переменных (их значения вычисляются при работе функции). Текст функции заканчивается словом end. Если возвращаемое значение одно, то можно написать заголовок так: function y = ext (x) где слово function является обязательным, у имя возвращаемой переменной, х имя аргумента, ext имя функции выбранное ее составителем по своему усмотрению. При сохранении в М-файл, конечно, файл будет называться так же как и функция и иметь расширение. m то есть ext. m.

Если возвращаемых значений много, то их заключают в квадратные скобки function [ a, b, c ]= ertVert (x, y, z) и когда необходимо вызвать функцию, например, в Command Window, то сначала определяют значения аргументов x,y,z, и уже затем вызывают функцию (без использования слова function, просто [ a, b, c ]= ertVert (x, y, z) и получают вывод в окне Command Window значений возвращаемых переменных).

Сначала рассмотрим ввод-вывод для программ, не снабженных индивидуальным визуальным интерфейсом. (Они уже упоминались чуть выше). Для ввода используется команда x = input (‘ x =?’) где х имя переменной, которая вводится. Для вывода используется команда disp (‘ a =’) и с ней еще disp (a).  Кроме того, можно не ставить точку с запятой при вычислении переменных и тогда они сразу будут появляться в Command Window. Если ввод-вывод программы не требует указания исходных аргументов и возвращаемых переменных, то скобки пишутся пустыми function []= ertVert 2()

Оператор УСЛОВНЫЙ. if. Оператор УСЛОВНЫЙ в MATLAB проверяет истинно или нет какое-то условие. Если условие истинно, то условный оператор возвращает единицу. Если ложно, то возвращает ноль. Оператор УСЛОВНЫЙ (рис.1.6) описывается в тексте как if. После него пишется условие. Если условие выполняется, то будет выполнено действие, описанное ниже. Однако если условие не выполняется, то не будет выполнено действие, описанное ниже условия. Произойдет переход к слову else, которое располагается ниже всех действий, выполняемых в случае, если условие выполнилось. Слово else означает начало описания всех тех действий, которые будут выполнены, если не выполнилось условие, указанное после слова if. После действий, выполняемых, если не выполнилось условие, указанное после слова if, пишется слово end, завершающее описание всех действий.

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

Сравнение числовых значений двух переменных	Пример Command Window	Пояснения
х==у (х равно у), «равно» указывается двойным знаком равенства х<у (х меньше у),  х>у (х больше у), х<=у (х меньше или равно у), х>=у (х больше или равно у), x~=y (х не равно у).	>> x=10; >> y=20; >> if x==y z=1 else z=0 end z = 0	Так как х<y то условие х==у не выполняется и тогда реализуется вариант действий, описанный после else то есть z =0. Описание завершается словом end. Потом происходит вывод ответа z=0.

Рис.1.6. Оператор условный if.

Условный оператор может использоваться как в Command Window, так и в функции и скрипте.

В М-файлах широко используется оператор if.

Он состоит из условия, варианта действий если оно выполняется, запасного варианта действий и иногда еще из условия№2 и варианта действий для него.

function[a,b,c]=exIF(x,y,z) a=0; b=0; c=0; if x==y    a=1; elseif x==z    b=1; else    c=1; end end

Пусть х=1, у=10, z=100. Тогда условие№1 (х==у) не выполняется. Тогда рассматривается второе условие (x==z). Оно тоже не выполняется. Тогда выполняется вариант№3 действий (с=1). Функция вернет значения a=0 b=0 c=1.

Оператор Условный, проверяя условие, возвращает ноль (если условие не выполняется) или единицу (если условие выполняется) и может присвоить это значение (1 или 0) переменной, поэтому можно написать в Command Window, что переменная равна условному оператору.

% Command Window

>> z=(x>y) z = 0

Например пусть х=2, у=3, тогда z =(x > y) приведет к ответу z=0, так как x > y неверно (ложно) и оператор Условный вернет ноль и присвоит его переменной z.

 

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

Смысл логического выражения заключается в том, что на основании значений (1 или 0) исходных переменных делается вывод (вычисляется возвращаемое значение 1 или 0) по правилам, предусмотренным для данного логического выражения.

Пусть исходные переменные называются Х и У. Они принимают значения 1 (истина) или 0 (ложь). Логическое выражение может быть конъюнкция (Х и У), дизъюнкция (Х или У), отрицание (не Х). Все остальные выражения могут быть сведены к последовательности конъюнкций, дизъюнкций и отрицаний.

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

Тип выражения	Логическое выражение	Логический оператор	Логическая операция
И	X and Y	and(X,Y)	X&Y
ИЛИ	X or Y	or(X,Y)	X|Y
Исключ. ИЛИ	X xor Y	xor(X,Y)	нет операции
НЕ	not X	not(X)	~X

Табл.1.1. Логические выражения.

Правила (Табл.1.2), по которым определяются возвращаемые значения для логических выражений, следующие:

Х	У	Не Х	Х и У	Х или У	Х исключающее или У
		~X	X&Y	X|Y
0	1	>> z=~x z = 1	>> z=x&y z = 0	>> z=x|y z = 1
		not(X)	and(X,Y)	or(X,Y)	xor(X,Y)
0	1	>> z=not(x) z = 1	>> z=and(x,y) z = 0	>>z=or(x,y) z = 1	>> z=xor(x,y) z = 1
0	0	1	0	0	0
0	1	1	0	1	1
1	0	0	0	1	1
1	1	0	1	1	0

Табл.1.2. Правила логических выражений.

Х и У. Если обе переменные равны единице, то возвращается единица, иначе возвращается ноль. В тексте программы пишется как x & y или and (x, y).

Х или У. Если хотя бы одна из переменных равна единице, то возвращается единица, иначе ноль. В тексте программы пишется как x | y или or (x, y).

Не Х. Если Х единица то возвращается ноль. Если Х ноль то возвращается единица. В тексте программы пишется как ~ x или not (x).

Исключающее или. Если Х и У не одинаковые, возвращает единицу. Если Х или У имеют одинаковое значение (оба истинны или оба ложны) то тогда возвращает ноль. В тексте программы пишется как xor (x, y).

function St_2 a=2; b=5; x=(a<b) y=(a==b) a1=and(x,y) a2=or(x,y) a3=~x x=10; y=100; a4=(x==y) a5= (x>y) a6=(x<y) end

Так как a < b истинно, то оператор Условный вернет 1 и тогда выражение вида x =(a < b) приведет к тому, что будет присвоено значение х=1. Так как a == b ложно при данных значениях a и b, то оператор Условный вернет 0 и тогда выражение вида y =(a == b) приведет к тому, что будет присвоено значение y=0. Так как x=1, y=0, то and (x, y) вернет 0. Так как x=1, y=0, то or (x, y) вернет 1. Так как x=1, то ~ x вернет 0. Так как x=10, y=100, то x == y ложно, оператор Условный вернет 0 Так как x=10, y=100, то x > y ложно, оператор Условный вернет 0. Так как x=10, y=100, то x < y истинно, оператор Условный вернет 1.

x=1 y=0 a1=0 a2=1 a3=0 a4=0 a5=0 a6=1

Оператор СРАВНЕНИЯ. switch

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

Соответственно, либо выполняется вариант действий для совпавшего (case) значения, либо вариант действий (otherwise) на случай если ничего не совпало. Функция Start_exSwitch задает x=1 и вызывает функцию exSwitch. Результаты выводятся в Command Window.

function[a,b,c]=exSwitch(x) a=0; b=0; c=0; switch x    case x<0        a=1;    case x<10        b=1;    otherwise        c=1; end end

function Start_exSwitch x=1; [a,b,c]=exSwitch(x) end   a= 0   b= 1 c= 0

Так как неверно что х<0 то а не изменилось Так как верно что x <10 то b  изменилось и стало равно 1

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

Цикл С ПРЕДУСЛОВИЕМ. while

Цикл while x >0 повторяет пока верно указанное условие.

Цикл СО СЧЕТЧИКОМ. for

Цикл for x =1:3 присваивает переменной х указанное начальное значение 1, и затем после каждой итерации увеличивает его на шаг по умолчанию 1. Когда переменная х превысит указанное максимальное значение 3, то цикл прекратится.

Цикл for x =1:0.1:3 присваивает переменной х указанное начальное значение 1, и затем после каждой итерации увеличивает его на указанный шаг 0,1. Когда переменная х превысит указанное максимальное значение 3, то цикл прекратится.

Прерывание цикла break, continue

Важное значение имеют три разных случая.

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

Во втором случае требуется, чтобы при каком-то условии (в случае если условие верно) прекратить циклический повтор и выйти из цикла, продолжив работу программы с той строки, которая расположена после конца цикла (после оператора end). Это обеспечивается оператором break.

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

Операторы break и continue можно использовать в одном и том же цикле, причем неоднократно. Функция Start_exWhileFor задает x=1, y=2, z=5 и запускает функцию exWhileFor. Результаты выводятся в Command Window.

function[]=exWhileFor(x,y,z) a=x+y; b=0; c=0; while a<z    for i=1:3        a=a+i    end    b=b+1 end c=1 end

function Start_exWhileFor x=1; y=2; z=5; exWhileFor(x,y,z) end a = 4 a = 6 a = 9 b = 1 c = 1

Цикл while повторяет пока верно указанное условие. Цикл for x =1:3 присваивает переменной х указанное начальное значение 1, и затем после каждой итерации увеличивает его на шаг по умолчанию 1. Когда переменная х превысит указанное максимальное значение 3, то цикл прекратится.

Цикл for x =1:0.1:10 присваивает переменной х указанное начальное значение 1, и затем после каждой итерации увеличивает его на указанный шаг 0,1. Когда переменная х превысит указанное максимальное значение 10, то цикл прекратится.

function[]=exContinueBreak(x,y,z) a=x+y; b=0; c=0; while a<z    for i=1:3                   if a>20            continue;        end        a=a+i    end    b=b+1    if b>3        break;    end end c=1 end

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

function Start_ exContinueBreak x=5; y=10; z=30; exContinueBreak(x,y,z) end a = 16 a = 18 a = 21 b = 1 b = 2 b = 3 b = 4 c = 1

Вызов одной функции из другой. feval

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

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

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

Опишем функцию exFun (x, y). Ее в дальнейшем будем вызывать в качестве одного из аргументов функции exFeval (x, y, nameFunction).

Для работы функции exFun необходимо передавать функции exFun значения двух переменных (аргументов функции). Поэтому укажем при вызове функции exFeval (x, y, nameFunction) два аргумента. Их значения будут использоваться в качестве аргументов функции exFun.

Саму же функцию exFun мы передадим при вызове функции exFeval (x, y, nameFunction) в качестве аргумента функции, названного в ее описании как nameFunction.

Вызов будет выглядеть в Command Window следующим образом res = exFeval (x, y,' exFun ') где res возвращаемое значение функции exFeval, ‘ exFun ’ это функция exFun, переданная как строка символов, совпадающая с ее названием.

В составе функции exFeval есть вызов функции feval. Он выглядит следующим образом res = feval (nameFunction, x, y). В качестве аргумента nameFunction как раз и выступает переданное функции exFeval название (как строка символов) ‘ exFun ’. Соответственно, именно ее и вызовет функция feval. При этом x, y являются аргументами функции exFeval, они же передаются в функцию feval и они же будут аргументами функции exFun.

В результате функция exFun вычислит возвращаемое значение res и оно и будет возвращаемым значением функции feval и затем возвращаемым значением функции exFeval.

function a=exFun(x,y) a=x^2+y^2; end function res=exFeval(x,y,nameFunction) if x+y>0    res=1; else    res=feval(nameFunction,x,y); end end	function res=Start_exFun x=1; y=2; res=exFeval(x,y,'exFun') end res = 1
	function res=Start2_exFun x=-5; y=2; res=exFeval(x,y,'exFun') end res = 29

Функция со списком аргументов неизвестного заранее состава и количества. varargin

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

varargin указывается в описании функции в качестве аргумента, например exVar (varargin). Это означает, что пользователь при вызове функции укажет в круглых скобках несколько аргументов, например exVar (1,2,' a ',' q ',3). Это могут быть числа или символы (строки символов). Символы указываются в верхних одинарных кавычках (апостроф).

Если пользователь укажет имена переменных, то они не будут восприниматься как элементы массива varargin. Например, создать массив vectorArguments =[2,3,4,' d ',' f '] и передать его в качестве аргумента при вызове exVar (vectorArguments).

Это приведет к некорректной работе функции, аргументом которой предусмотрен varargin.

Функция isnumeric (varargin { i }) возвращает 1 (истина) или 0 (ложь) в зависимости от того, является ли элемент массива varargin с индексом i числом или нет

 

function[]=exVar(varargin) sum=0; len=length(varargin) x=varargin lenx=length(x) for i=1:length(varargin)    if isnumeric(varargin{i})==1        sum=sum+varargin{i}    else        disp('not numeric value');    end        end end	Многие функции MATLAB допускают обращение к ним с различным числом параметров. При этом в качестве аргумента в описании функции в М-файле используется имя массива varargin. Переменные размещаются в массиве. Его особенность в том, что переменные, являющиеся элементами массива, могут быть самых разных типов. Однако нельзя передавать заранее сформированный массив в вызове функции с аргументом типа varargin. Он будет считаться просто одной переменной.
Правильно >> exVar(1,2,'a','q',3) len = 5 x = [1] [2] 'a' 'q' [3] lenx = 5 sum = 1 sum = 3 not numeric value not numeric value sum = 6	Таким образом массив varargin имеет произвольное (определяемое пользователем) содержание. Количество элементов массива (его длину) определяют функцией length (varargin). Она возвращает количество элементов массива varargin.
Неверное использование >> vectorArguments=[2,3,4,'d','f']; >> exVar(vectorArguments) len = 1 x = ‘df' lenx = 1 not numeric value	Обращение к определенному (то есть известен его номер в массиве) элементу массива записывается так varargin{i} где i его номер (индекс). Однако нельзя передавать заранее сформированный массив в вызове функции с аргументом типа varargin. Он будет считаться просто одной переменной.
Неверное использование >> vectorArguments2=[2,3,4,5,6] vectorArguments2 =2 3 4 5 6 >> exVar(vectorArguments2) len = 1 x =     [1x5 double] lenx = 1 sum = 2 3 4 5 6	Пользователь при вызове М-функции (например, в Command Window) указывает, как обычно, имя функции и в скобках ее аргумент. Но не имя массива varargin, а его содержимое (то есть его элементы через запятую). Функция isnumeric (varargin { i }) возвращает 1 или 0 в зависимости от того, является ли элемент массива varargin с индексом i числом или нет.

Отладка функций осуществляется с помощью пункта меню Debug.

Так, например, предусмотрены точки останова Debug—Set—Clear Break Points.

Также есть точки останова с помощью команды. В них можно задать условие, останавливающее (в случае его выполнения) работу программы. Они расположены в Debug—Set—Modify Conditional.

Пошаговое выполнение Debug—Step  или Debug—Step In.

Выполнение до курсора Debug—Go Until Cursor.