LabVIEW MathScript

Содержание
стр
1. Общие сведения о MathScript ………………………………………………………… 2
1.1. Окно и узел MathScript …………………………………………………………………… 2
1.2. Функции и структуры программирования MathScript ……………………………. 3
1.3. Типы данных ……………………………………………………………………………….. 4
1.4. Определение переменных ………………………………………………………………. 6
1.5. Создание функций пользователя ……………………………………………………… 7
2. Использование MathScript для решения математических задач ……. 7
2.1. Решение задач линейной алгебры …………………………………………………..... 7
2.1.1. Общие сведения о векторах и матрицах …………………………………………….…….. 7
2.1.2. Создание векторов и матриц …………………………………………………………………. 8
2.1.3. Операции преобразования векторов и матриц …………………………………….…... 9
Операции изменения конфигурации матриц ………………………………………………….. 9
Операции математической обработки векторов и матриц …………………………….….. 10
2.2. Решение обыкновенных дифференциальных уравнений и систем …………… 18
2.3. Операции с полиномами ………………………………………………………………..… 21
2.4. Статистические функции ………………………………………………………….……… 23
2.5. Функции оптимизации ……………………………………………………………………… 26
Список литературы ……………………………………………………………………………………
1
1. Общие сведения о MathScript
1.1. Окно и узел MathScript
LabVIEW 8.2 позволяет объединить графическое программирование потока данных с MathScript – текстовым языком математической обработки, включающим свыше 500 функций математики, обработки сигналов и
анализа результатов. Синтаксис функций и скриптов MathScript в общих чертах совместим с синтаксисом
скриптов m-файлов, которые широко используются в таком пакете технических расчетов, как MATLAB. Такая
совместимость позволяет использовать в LabVIEW множество скриптов m-файлов, опубликованных в технической литературе или на Web-сайтах.
MathScript поддерживает как интерактивный, так и программный интерфейс с LabVIEW.
Интерактивный интерфейс поддерживается с помощью окна MathScript (MathScript Window) (рис. 1), которое запускается с помощью меню ИнструментыОкно MathScript (ToolsMathScript Window) и включает
окно вывода (Output Window), окно команд (Command Window), индикатор состояния (Status) и набор страниц с окнами: переменные (Variables), скрипт (Script) и история (History). Окно вывода отображает команды,
которые вводятся в окне команд, и содержимое, которое создает MathScript при выполнении этих команд. Для
ввода многострочных команд необходимо нажать клавиши <Shift-Enter>. С помощью клавиш со стрелками
можно выводить на индикацию в окне команд пункты из окна история команд (Command History), редактировать их и запускать на повторное выполнение.
Рис. 1. Вид окна MathScript
Окно MathScript используется для редактирования и выполнения математических команд, создания математических скриптов и отображения переменных в табличном или графическом виде. В этом окне выполняется
большинство скриптов, записанных в соответствии с синтаксисом языка MATLAB, но некоторые функции этого языка не поддерживаются и приводят к генерации сообщений об ошибке.
Программный интерфейс осуществляется с помощью узла MathScript (MathScript Node) – структуры, которая позволяет выполнять скрипты в блок-диаграмме LabVIEW. На рисунке 2 показан вид узла MathScript из
ВП MathScript Fundamentals, находящегося в библиотеке примеров NI Example Finder.
Рис. 2. Вид узла MathScript
Доступ к узлу MathScript обеспечивается с помощью подпалитры Структуры, находящейся в категории
Программирование, или подпалитры Скрипты и формулы (Scripts & Formulas), размещенной в категории
Математика.
2
1.2. Функции и структуры программирования MathScript
Перечень основных классов функций MathScript приведен в таблице:
класс
описание
advanced
Дополнительные математические функции
approximation
Аппроксимация, интегрирование и интерполяция
audio
Звуковые функции
basic
Основные математические функции
bitwise
Функции побитовой обработки
boolean
Логические функции
commands
Команды
comparison
Операции сравнения
constants
Константы
daq
Сбор данных
dsp
Цифровая обработка сигналов
geometry
Комбинаторная геометрия
libraries
Загрузка, выгрузка и вызовы общих библиотек
linalgebra
Линейная алгебра
matrix
Специальные матрицы
matrixops
Операции с матрицами
membership
Функции принадлежности
ode
Решение ОДУ
optimization
Оптимизация и минимизация
plots
Функции построения графиков
polynomials
Полиномиальные функции
programming
Структуры программирования
sets
Операторы работы с множествами
statistics
Статистика
string
Строковые функции
support
Функции поддержки
time
Функции даты и времени
timing
Функции синхронизации
trigonometric
Тригонометрические функции
vector
Векторный анализ
В следующей таблице приведен список членов класса функций Цифровая обработка сигналов (dsp), которые, в свою очередь, сами являются классами функций:
filter design
Конструирование фильтров
filter implementation
Реализация фильтров
linear systems
Линейные системы
modeling and prediction
Моделирование и прогнозирование
resampling
Функции изменения частоты выборки
spectral analysis
Спектральный анализ
transforms
Преобразования
waveform generation
Генерация осциллограмм
windows
Генерация окон
3
Ниже в таблице представлены члены класса Структуры программирования (programming):
конструкция
грамматика
пример
Оператор CaseSwitch
switch выражение
case выражение
группа инструкций
[case выражение
группа инструкций]
...
[otherwise
группа инструкций]
end
switch mode
case 'start'
a = 0;
case 'end'
a = –1;
otherwise
a = a+1;
end
For Loop
for выражение
группа инструкций
end
for i = 1:10
a = sin(2*pi*i/10)
end
Оператор If-Else
if логическое выражение
группа инструкций
[elseif логическое выражение
группа инструкций]
...
[else
группа инструкций]
end
if b == 1
c=3
else
c=4
end
Range
start:[step:]end
b = 2:2:20
b возвращает четные числа от 2 до 20.
Если размер шага не задан, MathScript
использует шаг, равный 1
While Loop
while выражение
группа инструкций
end
while i < 10
a = cos(2*pi*i/10)
i = i + 1;
end
1.3. Типы данных
Наиболее широко в диалоговом режиме работы в окне MathScript используются данные числового типа.
Они могут быть целыми или вещественными. Последние, в свою очередь, могут отображаться в формате с плавающей или фиксированной точкой. Перечень вариантов представления включает следующие опции:
 short – отображает 5 цифр в формате с фиксированной десятичной точкой, например 314.15927;
 long – отображает 15 цифр в формате с фиксированной десятичной точкой, например
314.159265358979326;
 short e – отображает 5 цифр в формате с плавающей десятичной точкой, например 3.14159E+2.
 long e – отображает 15 цифр в формате с плавающей десятичной точкой, например
3.141592653589793E+2.
Формат отображения чисел может устанавливаться как интерактивно (вручную), так и программно. Ручной
вариант установки реализуется в диалоговом окне MathScript Preferences, которое вызывается с помощью строки меню ФайлПредпочтения (FilePreferences). Для программного изменения формата отображения чисел
используется функция format, входящая в класс support. Эта функция изменяет отображение всех чисел.
MathScript поддерживает выполнение арифметических операций только для чисел двойной точности. При
создании число или матрица имеют по умолчанию именно этот формат. Вместе с тем, для сохранения чисел с
таким форматом требуется больше памяти, чем для целых чисел. Для взаимного преобразования форматов целых и вещественных числовых переменных служит ряд функции из класса support (таблица).
int64
Преобразует в 64-битовые целые со знаком
int32
Преобразует в 32-битовые целые со знаком
int16
Преобразует в 16-битовые целые со знаком
int8
Преобразует в 8-битовые целые со знаком
uint64
Преобразует в 64-битовые целые без знака
uint32
Преобразует в 32-битовые целые без знака
uint16
Преобразует в 16-битовые целые без знака
uint8
Преобразует в 8-битовые целые без знака
double
Преобразует в числа с двойной точностью
single
Преобразует в числа с одинарной точностью
4
Число в имени функции определяет размер памяти, отводимой для хранения числа, в битах. Вещественные
данные могут быть числами одинарной (single – 4 байта) и двойной (double – 8 байт) точности.
Для выполнения математических операций в MathScript используются следующие операторы:
функция
описание
abs(x)
абсолютное значение
angle(x)
аргументы комплексных чисел
cart2pol(x,y,z)
прямоугольную в полярную (цилиндрическую)
cart2sph(x,y,z)
прямоугольную в сферическую
ceil(x)
округление до ближайшего целого справа от x
conj(x)
комплексное сопряжение
cplxpair(x)
сортирует комплексные числа по комплексно-сопряженным парам
cumprod(x)
накопленные произведения
cumsum(x)
накопленные суммы
exp(x)
экспонента
expm(x)
матричная экспонента
factor(x)
простые множители
factorial(x)
N!
fix(x)
округление до ближайшего целого в сторону нуля
floor(x)
округление до ближайшего целого слева от x
gcd(x,y)
наибольший общий делитель
imag(x)
мнимая часть
lcm(x,y)
наименьший общий множитель
log(x)
натуральный логарифм
logm(x)
матричный натуральный логарифм
log10(x)
логарифм по основанию 10
log2(x)
логарифм по основанию 2
max(x)
наибольший элемент
min(x)
наименьший элемент
mod(x,y)
остаток по модулю
nextpow2(x)
следующая степень 2
planerot(x)
матрица поворота
pol2cart(x,y,z)
полярную (цилиндрическую) в прямоугольную
pow2(x)
степень 2
prod(x)
произведение
real(x)
действительная часть
reallog(x)
натуральный логарифм положительных вещественных чисел
realpow(x,y)
степени для каждого элемента
realsqrt(x)
квадратные корни из положительных вещественных чисел
rem(x,y)
остаток
round(x)
округление до ближайшего целого
sign(x)
знаки элементов матрицы
sort(x)
сортирует элементы векторов или матриц
sortrows(x)
сортирует строки матрицы в порядке возрастания
sph2cart(x,y,z)
сферическую в прямоугольную
sqrt(x)
извлечение квадратного корня
sqrtm(x)
матричная операция извлечение квадратного корня
sum(x)
сумма
5
Отдельный класс функций MathScript образуют тригонометрические функции (trigonometric), перечисленные в таблице
функция
описание
sin(x), cos(x)
tan(x), cot(x)
синус, косинус, тангенс, котангенс (аргумент x – в радианах)
sec(x), csc(x)
секанс и косеканс
asin(x), acos(x)
обратные тригонометрические функции (возвращают
результат в радианах)
atan(x), acot(x)
asec(x), acsc(x)
sinh(x), cosh(x)
гиперболические тригонометрические функции
tanh(x), coth(x)
sech(x), csch(x)
asinh(x), acosh(x)
atanh(x), acoth(x)
обратные гиперболические тригонометрические функции
asech(x), acsch(x)
sinc(x)
функция sin(x)/x
atan2(x,y)
арктангенс, определяемый с учетом квадрантов (возвращают результат в радианах)
1.4. Определение переменных
В MathScript можно определять переменные, а затем использовать их в выражениях. Процедура определения заключается в присваивании переменной, заданной именем, значения выражения. Имя переменной не
должно совпадать с именами встроенных процедур, функций и встроенных переменных системы. Имена переменных должны начинаться с буквы и не могут содержать математические символы и знаки пунктуации. В
именах переменных должны использоваться только символы ASCII. Запись имени чувствительна к регистру.
Выражение в правой части оператора присваивания может быть числом, арифметическим выражением,
строкой символов или символьным выражением. Переменные MathScript изменяются в соответствии с типом
данных. Так, например, если a=sin(3*pi/2), то a – вещественное число двойной точности, если же a=’result’, то a
становится строковой переменной.
Если символ «;» в конце выражения отсутствует, то в качестве результата выводится имя переменной и ее
значение. Наличие символа «;» передает управление следующей командной строке. Если команда не содержит
знака присваивания, то по умолчанию вычисленное значение присваивается специальной системной переменной ans.
Помимо ans в число системных переменных входят pi – число  , i,j – мнимая единица (  1 ), inf – машинный
символ бесконечности и NaN – неопределенный результат (0/0,  /  и т.п.). При вводе комплексных чисел
мнимая единица может быть записана до или после мнимой части. В первом случае после мнимой единицы
должен находиться знак умножения «*», во втором случае он необязателен, однако мнимая часть и последующая мнимая единица должны быть записаны слитно.
Любая переменная в MathScript является матрицей, в простейшем случае это матрица, состоящая из одной
строки и одного столбца. Переменную, представляющую простой список данных, называют одномерным массивом или вектором. Для доступа к данным, хранящимся в определенном элементе массива, необходимо указать имя массива и порядковый номер этого элемента, называемый индексом.
При необходимости хранения данных в виде таблиц, содержащих строки и столбцы, используют двумерные
массивы (матрицы). Для доступа к элементам такого массива указывают имя массива и два индекса: первый
должен соответствовать номеру строки, а второй – номеру столбца, на пересечении которых находится искомый элемент. Индексация массивов начинается с единицы. Индексы могут быть только целыми положительными числами или нулем.
Для доступа к отдельной строке вместо второго индекса вводится двоеточие. Аналогично доступ к столбцу
обеспечивается вводом двоеточия вместо первого индекса.
Элементы массивов могут быть введены вручную или рассчитаны программно. Так, для определения вектора-строки необходимо ввести имя массива, а затем, после знака присваивания в квадратных скобках перечислить элементы массива, отделяя их друг от друга пробелами или запятыми. Элементы вектора-столбца вводятся
через точку с запятой. Подобным же образом элементы в строках матрицы разделяются пробелами или запятыми, а строки – точками с запятыми.
Один из способов программного создания массива связан с использованием конструкции
[name] = Xn:dX:Xk,
где name – имя переменной,
в которую будет записан сформированный массив, Xn, Xk – значение первого и
последнего элементов массива, dX – шаг, с помощью которого формируется каждый следующий элемента массива.
6
Ограничения на создание массивов в MathScript связаны с тем, что их размерность не должна превышать 2 и
их элементами не могут быть кластеры.
1.5. Создание функций пользователя
Наряду с встроенными функциями MathScript позволяет пользователю определять собственные функции.
При записи собственной функции она должна иметь следующий синтаксис:
function outputs=function_name(inputs)
%documentation
script
Определение каждой функции начинается со слова function.
outputs представляет список выходных переменных функции. Если функция имеет более одной выходной
переменной, необходимо заключить их в квадратные скобки и отделить друг от друга запятыми или пробелами.
function_name представляет имя определяемой функции.
inputs содержит список входных переменных функции, которые разделяются запятыми.
documentation представляет содержимое справочного сообщения, которое будет выводиться LabVIEW для
данной функции при вызове пользователем команды помощи (help). В начале каждой строки справочной информации должен находиться символ %.
script определяет исполняемое тело функции.
В следующей таблице приведены варианты определения функций.
function foo
function a = foo
function [a b] = foo
function foo()
function a = foo()
function [a b] = foo()
function foo(g)
function a = foo(g)
function [a b] = foo(g)
function foo(g, h)
function a = foo(g, h)
function [a b] = foo(g, h)
Если в одном файле MathScript определено несколько функций, то все функции, введенные вслед за первой,
становятся ее подфункциями и доступны только для главной функции. Функция может вызвать только те
функции, которые находятся ниже ее. Поэтому функция не может вызвать саму себя. LabVIEW также не разрешает циклические рекурсивные вызовы функции. Например, foo не может вызвать bar, если bar вызывает foo.
Пользователь может определить для функции дополнительные входы и выходы. Функция nargin позволяет
определить число входных аргументов, поддерживаемых функцией, которая вызывает nargin. Если число поддерживаемых входов меньше максимального числа входов для этой функции, то свободным входам могут быть
присвоены значения по умолчанию. Подобным же образом функция nargout позволяет определить число выходных аргументов, запрошенных функций. Если число запрошенных выходов меньше максимального числа выходов функции, то вычисление незапрошенных выходов может быть исключено.
После определения функции ее необходимо сохранить в папке, путь к которой указан в диалоговом окне
MathScript Preferences. Диалоговое окно вызывается с помощью строки меню ФайлПредпочтения
(FilePreferences). Имя файла функции должно быть таким же, как и имя самой функции и должно иметь расширение .m в нижнем регистре.
2. Использование MathScript для решения математических задач
2.1. Решение задач линейной алгебры
Решение задач линейной алгебры основано на выполнении различных операций с векторами и матрицами.
2.1.1. Общие сведения о векторах и матрицах
Базовым элементом, используемым в в MathScript, является матрица (Matrix). Матрицей называется прямоугольная таблица, состоящая из n строк и m столбцов [1]. Для определения матрицы используется следующее
обозначение:
 a11 a12 ... a1m 


 a 21 a 22 ... a 2 m 
= a ij .
A
...
... ... ... 


a

 n1 a n 2 ... a nm 
В приведенной записи первый индекс i элемента a ij обозначает номер строки, второй индекс j – номер
 
столбца. Если mn, матрица называется прямоугольной, в противном случае – квадратной. При n=1 имеет место
вектор-строка, при m=1 – вектор-столбец. При n=1 и m=1 матрица состоит из одного элемента.
Число строк или столбцов квадратной матрицы называется ее порядком. Диагональ квадратной матрицы,
которая содержит элементы a11 , a 22 ,… a nn называется главной, а диагональ, содержащая элементы
a1n , a 2 n 1 ,… a n1 – вспомогательной. Если квадратная матрица содержит ненулевые элементы только на главной диагонали, она называется диагональной. Если при этом все диагональные элементы равны единице, матрица называется единичной. Если все элементы ниже главной диагонали равны нулю, матрица является верхней
треугольной. С другой стороны, если равны нулю все элементы выше главной диагонали, то матрица является
нижней треугольной. Когда все элементы являются вещественными числами, матрица является вещественной.
7
В том случае, когда хотя бы один из элементов матрицы является комплексным, матрица является комплексной.
2.1.2. Создание векторов и матриц
Вектор или матрица может создаваться в окне команд как с помощью непосредственного ввода числовых
значений, так и с помощью соответствующих функций.
При непосредственном вводе элементы вектора-строки отделяются пробелами или запятыми, а вся конструкция ограничивается квадратными скобками. Элементы вектора-столбца отделяются друг от друга точкой
с запятой «;». При вводе матрицы используются оба способа разделения элементов.
Пример создания матрицы с помощью ввода чисел:
>>A=[1.1 2.5 3; 4.6 5 6]
A=
1.1
2.5
3
4.6
5
6
Для генерации матриц могут использоваться функции из категорий Специальные матрицы (matrix) и Линейная алгебра (linalgebra). Перечень видов матриц, которые можно рассчитать с помощью функций из категории Специальные матрицы, приведен в следующей таблице.
Функция
Описание
eye
Единичная матрица
false
Матрица из булевских нулей
hadamard
Матрица Адамара
hankel
Матрица Ганкеля
hilb
Матрица Гильберта
invhilb
Обратная матрица Гильберта
magic
Магический квадрат
ones
Матрица из единиц
pascal
Матрица Паскаля
peaks
Пиковая функция двух переменных
perms
Все перестановки
primes
Простые числа
repmat
Матрица из повторяющихся элементов
rosser
Матрица Рессера
toeplitz
Матрица Теплица
true
Матрица из булевских единиц
vander
Матрица Вандермонда
wilkinson
Матрица Вилкинсона
zeros
Матрица нулей
С помощью функций из категории Линейная алгебра можно создать новую матрицу путем комбинирования существующих. Простейшими примерами таких функций являются функции horzcat и vertcat соответственно для горизонтального и вертикального объединения матриц.
horzcat
Объединяет по горизонтали входные матрицы. horzcat(a, b, ...) эквивалентно [a, b, ...]. Может быть объединено неограниченное число матриц. При этом они должны иметь одинаковое число строк
c = horzcat(a, b, ...)
a и b определяют матрицы.
c является матрицей и возвращает горизонтальное объединение матриц a и b.
>>A = [1, 2; 3, 4]
B = [5, 6; 7, 8]
C = horzcat(A, B)
A=
1
3
2
4
B=
5
7
6
8
C=
1
3
2
4
5
7
6
8
Функция vertcat аналогична функции horzcat, но производит объединение входных матриц по вертикали. Существует и общая функция cat для объединения матриц как по горизонтали, так и по вертикали.
cat
Объединяет матрицы. Может быть задано неограниченное количество матриц
c = cat(d, a, b, ...)
8
d определяет формат, в котором LabVIEW объединяет входные матрицы, и принимает следующие целые значения:
1. объединяет a и b, используя следующее равенство: cat(1, a, b, ...) = [a; b; ...].
Функция cat(1, a, b, ...) эквивалентна vertcat(a, b, ...). a и b должны иметь одинаковое число столбцов.
2. объединяет a и b в соответствии со следующим равенством: cat(2, a, b, ...) = [a, b, ...].
cat(2, a, b, ...) эквивалентна horzcat(a, b, ...). a и b должны иметь одинаковое число строк.
c возвращает объединенную матрицу
>>A = [1, 2; 3, 4]
B = [5, 6; 7, 8]
C = cat(2, A, B)
A=
1
3
2
4
B=
5
7
6
8
C=
1
2
5
6
3
4
7
8
Исходные матрицы могут объединяться и по диагонали с помощью функции blkdiag.
blkdiag
Создает матрицу c со следующей структурой: c = [a, 0, … , 0; 0, b, 0, …]. Можно задать неограниченное количество матриц
c = blkdiag(a, b, .)
a определяет первую матрицу
b определяет вторую матрицу
с возвращает блочную диагональную матрицу
>>A = [1, 2; 3, 4]
B = [5, 6; 7, 8]
C = blkdiag(A, B)
A=
1
3
2
4
B=
5
7
6
8
C=
1
3
0
0
2
4
0
0
0
0
5
7
0
0
6
8
2.1.3. Операции преобразования векторов и матриц
Над векторами и матрицами могут быть выполнены как математические операции, так и операции по изменению их конфигурации. К последним можно отнести изменение размеров матриц, их транспонирование и
циклический сдвиг, различного рода повороты и определение углов между столбцами матриц. В следующих
таблицах рассмотрены операции, которые выполняют такие преобразования.
Операции изменения конфигурации матриц
tril
Возвращает нижнюю треугольную часть матрицы
c = tril(a)
c = tril(a, b)
a определяет матрицу.
b определяет диагональ в матрице a. b является целым.
c возвращает нижнюю треугольную часть a. Если b задана и не равна 0, c возвращает все элементы a на и ниже b-й диагонали. c
является матрицей того же размера, что и a
Функция triu аналогична tril, но возвращает верхнюю треугольную часть матрицы.
reshape
Изменяет размеры входной матрицы
d = reshape(a, b, c)
a определяет матрицу. Число элементов в матрице a должно быть равно b*c.
b определяет количество строк в матрице d. b является положительным целым.
c определяет количество столбцов в матрице d. c является положительным целым.
d возвращает матрицу размером b х c. Элементы в матрице d являются элементами матрицы a, следующими по столбцам
>>A = [1, 2, 3; 4, 5, 6]
D = reshape(A, 3, 2)
A=
1
4
2
5
3
6
D=
1
4
2
5
3
6
Функции transpose и ctranspose выполняют транспонирование матриц.
transpose
Вычисляет несопряженное транспонирование матрицы.
c = transpose(a)
a определяет матрицу.
c возвращает несопряженное транспонирование матрицы a. c является матрицей того же размера, что и матрица a
>>A = [1-i, 3+4i; 5-7i, -i]
C = transpose(A)
A=
1 - 1i
5 - 7i
3 + 4i
0 - 1i
C=
1 - 1i
3 + 4i
5 - 7i
0 - 1i
Ctranspose
Вычисляет комплексно-сопряженное транспонирование матрицы. ctranspose(a) эквивалентно a'
c = ctranspose(a)
a определяет матрицу.
9
c возвращает комплексно-сопряженное транспонирование матрицы a. c является матрицей того же размера, что и матрица a
>>A = [1-i, 3+4i; 5-7i, -i]
C = ctranspose(A)
A=
1 - 1i
5 - 7i
3 + 4i
0 - 1i
C=
1 + 1i
3 - 4i
5 + 7i
0 + 1i
Следующие функции служат для выполнения различных поворотов матриц.
flipdim
Поворачивает матрицу по заданной размерности
c = flipdim(a, b)
a определяет поворачиваемую матрицу.
b определяет размерность, по которой производится поворот матрицы a.
Переменная b является целой и принимает следующие значения:
1. – поворачивает строки матрицы а
2. – поворачивает столбцы матрицы а
c возвращает матрицу a с повернутыми элементами. c имеет то же размер, что и а
>>A = [1, 2, 3, 4; 5, 6, 7, 8]
C = flipdim(A, 1)
A=
1
5
2
6
3
7
4
8
C=
5
1
6
2
7
3
8
4
Функция fliplr поворачивает матрицу слева направо, а функция flipud – сверху вниз.
rot90
Поворачивает матрицу против часовой стрелки на угол, кратный 90 градусов
c = rot90(a)
c = rot90(a, b)
a определяет поворачиваемую матрицу.
b определяет коэффициент кратности угла 90 градусов при расчете угла поворота матрицы a. b является целым и по умолчанию
равен 1.
c возвращает матрицу a, повернутую против часовой стрелки на угол, равный b*90 градусов. c – матрица с тем же числом элементов, что и a
>>A = [1, 2, 3; 4, 5, 6]
C = rot90(A)
A=
1
4
2
5
3
6
C=
3
2
1
6
5
4
circshift
Выполняет циклический сдвиг элементов матрицы
c = circshift(a, b)
a определяет матрицу.
b описывает сдвиг, который должен быть выполнен. Если b содержит два элемента, то элементы в a сдвигаются вниз на число
позиций, которые определяются первым элементом, и вправо на количество позиций, которые определяются вторым элементом.
Если b имеет только один элемент, элементы в a сдвигаются вниз на b мест. b является вектором с целыми значениями.
c возвращает матрицу a вместе со сдвинутыми элементами
>>A = [1, 2; 3, 4; 6, 7]
B = [1, 1]
C = circshift(A, B)
A=
1
3
6
2
4
7
B=
1
1
C=
7
2
4
6
1
3
Операции математической обработки векторов и матриц
В совокупности операций математической обработки можно выделить арифметические операции, выполняемые функциями, которые входят в категорию Матричные операции (matrixops), и ряд операций, которые
выполняются функциями из категории Линейная алгебра. В следующей таблице перечислены функции арифметических операций.
Символ
(функция)
операция
операнды
+
(plus())
Матричное сложение
–
(minus())
Матричное вычитание
Оба операнда должны иметь одинаковые размеры или один из них должен быть
скаляром. В последнем случае в операции со скаляром участвуют все элементы
массива, и результат будет иметь тот же размер, что и исходный массив
.*
(times())
Поэлементное умножение массива
.\
(ldivide())
Поэлементное левое
деление массивов
./
(rdivide())
Поэлементное правое
деление массивов
.^
(power())
Поэлементное возведение массива в сте-
10
пень
*
Матричное умножение
Число столбцов первого операнда A должно быть равно числу строк второго опеm
(mtimes())
ранда B. Тогда C  A * B  [ aij ] * [ bik ]  [ c ik ] , где c ik 
a b
ij jk
j 1
\
(mldivide())
Левое матричное деление
Операция X=A\B используется для решения системы линейных алгебраических
уравнений A*X=B
/
(mrdivide())
Правое матричное
деление
Операция X=A/B используется для решения системы линейных алгебраических
уравнений X*A =B
Как видно из таблицы, для выполнения поэлементных мультипликативных операций (.*, ./, .\, и .^) перед соответствующим знаком должна быть установлена точка.
В палитру Линейная алгебра включены такие функции как матричная степень, экспонента и матричный
логарифм.
mpower
Вычисляет матричную степень
c = mpower(a, b)
a определяет скаляр или квадратную матрицу. Если b является матрицей, то a должна быть скаляром.
b определяет скаляр или квадратную матрицу. Если a является матрицей, то b должна быть скаляром.
с возвращает a^b. c является квадратной матрицей
>>A = [1+3i, 5.6; -2.3, 8-i]
B=3
C = mpower(A, B)
A=
1 + 3i
-2.3 + 0i
5.6 + 0i
8 - 1i
B=
3
C=
-154.8 - 82.4i
-122.18 - 29.9i
297.47 + 72.8i
269.04 - 203.88i
expm
Вычисляет матричную экспоненту
c = expm(a)
a определяет квадратную матрицу.
c возвращает матричную экспоненту матрицы a. c является квадратной матрицей
Функции expm1, expm2 и expm3 вычисляют матричную экспоненту с помощью соответственно аппроксимации Паде, ряд
Тейлора и собственных векторов. National Instruments рекомендует использовать взамен функцию expm.
logm
Вычисляет матричный логарифм
c = logm(a)
a определяет квадратную матрицу.
c возвращает матричный логарифм матрицы a. c является квадратной матрицей
>>E = diag([2.7183, 0.3679])
C = logm(E)
E = 2.7183 0
0
0.3679
C=
1 - 8.5562e-029i
3.6228e-015 + 1.4108e-014i
3.412e-015 + 1.3625e-014i
-0.99994 - 1.9474e-029i
Особый класс образуют функции, которые производят расчет различных параметров матриц, как элементарных, так и достаточно сложных, а также функции, которые преобразуют матрицы к виду, удобному для решения определенных задач. К числу функций, позволяющих получить элементарные параметры матриц, можно
отнести следующие:
det
Вычисляет определитель квадратной матрицы
c = det(a)
a определяет квадратную матрицу.
c возвращает определитель матрицы a. c является числом
>>A = [3, 2, -1; 1, 6, 3; 2, -4, 0]
C = det(A)
A=
3
1
2
2
6
-4
-1
3
0
C=
64
size
Возвращает размеры матрицы
c = size(a)
d = size(a, dim)
[m, n] = size(a)
a определяет матрицу.
dim определяет размерности, по которым должен возвращаться размер. dim является целым числом, которое принимает следующие значения:
11
1. определяет, что LabVIEW возвращает размер по первой размерности.
2. определяет, что LabVIEW возвращает размер по второй размерности.
c возвращает размеры матрицы a. c является вектором из двух элементов.
d возвращает размер по размерности dim матрицы a. d является скаляром.
m и n возвращают размеры соответственно по первой и второй размерностям матрицы a и являются скалярами.
>>A = [1, 4; 53, 16; 0, -81];
C = size(A)
C=
3
2
find
Возвращает индексы всех ненулевых элементов матрицы
[i, j] = find(a)
[i, j, c] = find(a)
a определяет матрицу.
i возвращает первые индексы всех ненулевых элементов матрицы a. i является вектором-столбцом.
j возвращает вторые индексы всех ненулевых элементов матрицы a. j является вектором-столбцом.
c возвращает все ненулевые элементы матрицы a. c является вектором-столбцом.
>>A = [1, 2, 3; 0, 0, 0; 0, 2, 3]
[I, J] = find(A)
A=
1
0
2
0
3
0
0
2
3
I=
1
1
3
1
3
J=
1
2
2
3
3
Перечисленные ниже функции возвращают следующие параметры матриц:
ndims – размерность входной матрицы,
nnz – число ненулевых элементов,
nonzeros – ненулевые элементы,
numel – число элементов матрицы
Следующие функции вычисляют более сложные параметры матриц.
norm
Рассчитывает норму вектора или матрицы
k = norm(a)
k = norm(a, type)
a определяет вектор или матрицу.
type определяет тип нормы. type является скаляром или строкой, которые принимают следующие значения:
1 – рассчитывает 1-norm, равную наибольшей сумме модулей элементов входной матрицы по столбцам;
2 (по умолчанию) – рассчитывает 2-norm, равную наибольшему сингулярному значению входной матрицы;
inf – рассчитывает inf-norm, равную наибольшей сумме модулей элементов входной матрицы по строкам;
'fro' – рассчитывает норму Фробениуса, равную
 diag( a a ) , где diag( a a ) – диагональные элементы матрицы a a , а
T
T
T
aT – результат транспонирования матрицы a. Если а является вектором, тип нормы не может принимать значение 'fro'.
k возвращает норму матрицы а в соответствии с типом (type) нормы
>>A = [1, 2, 3; 4, 5, 6; 7, 8, 9]
C = norm(A, 'fro')
A=
1
4
7
2
5
8
3
6
9
C=
16.882
normest
Возвращает оценку евклидовой нормы для матрицы
k = normest(a)
k = normest(a, tol)
[k, ite] = normest(a)
[k, ite] = normest(a, tol)
a определяет матрицу.
tol определяет допуск. tol является действительным положительным числом.
k возвращает евклидову норму матрицы a. k является действительным положительным числом.
ite определяет число итераций. ite является положительным целым числом
>>A = [1, 2, 3; 4, 5, 6; 7, 8, 9]
K1 = norm(A, 2)
K2 = normest(A)
A=
1
4
7
2
5
8
3
6
9
K1 =
K2 =
16.848
16.848
cond
Возвращает число обусловленности матрицы, используя метод разложения по сингулярным значениям
c = cond(a)
c = cond(a, b)
a определяет матрицу.
12
b задает тип нормы матрицы a. Варианты b были перечислены выше в описании функции norm.
c – скаляр, который возвращает число обусловленности (собственное значение) матрицы а в соответствии с нормой b.
Число обусловленности рассчитывается с помощью выражения c = ||A||p||A–1||p, где ||A||p является нормой входной матрицы.
Различные значения p определяют различные типы нормы, соответственно p определяет и различные способы вычисления чисел
обусловленности.
Для 2-norm число обусловленности определяется как отношение наибольшего и наименьшего сингулярных значений входной
матрицы A.
Числа обусловленности матрицы определяют чувствительность решения системы линейных уравнений к ошибкам данных
>>A = [1+2i, 4i; -3-6i, -5i]
C = cond(A)
A=
1 + 2i
-3 - 6i
0 + 4i
0 - 5i
C=
5.6364
condest
Возвращает нижнюю оценку для числа обусловленности с типом нормы 1-norm квадратной матрицы
c = condest(a)
[c, d] = condest(a)
a определяет матрицу.
c возвращает нижнюю оценку для числа обусловленности с типом нормы 1-norm матрицы a.
d возвращает приближение нуль-вектора. Вектор d имеет размер, равный числу столбцов матрицы a
>>A = [1, 2, 3; 0, 1, 1; 4, 3, 1]
С = condest(A)
A=
1
0
4
2
1
3
С=
3
1
1
23
rcond
Возвращает оценку обратной величины числа обусловленности матрицы, рассчитанного по норме 1-norm
c = rcond(a)
a определяет матрицу.
с возвращает оценку обратной величины числа обусловленности матрицы a, рассчитанного по норме 1-norm. Если a плохо обусловлена, значение c мало. c представляет число двойной точности с плавающей запятой
>>A = [1, 2, 3; 0, 1, 1; 4, 3, 1]
D = rcond(A)
A=
1
0
4
2
1
3
3
1
1
D=
0.043478
rank
Возвращает ранг матрицы. LabVIEW определяет числовой ранг в соответствии с числом сингулярных значений, превышающих
допуск
n = rank(a, tol)
a определяет матрицу.
tol определяет допуск матрицы a. tol представляет скаляр. Если tol не задан, LabVIEW рассчитывает допуск, используя следующее соотношение: tol = max(size(a))*norm(a)*eps.
n возвращает ранг матрицы a. n является целым
>>B = [1, 2, 3; 4, 5, 6];
A = B'*B
rank(A)
A=
17
22
27
22
29
36
27
36
45
ans =
2
subspace
Вычисляет угол между двумя подпространствами
c = subspace(a, b)
a определяет матрицу.
b определяет матрицу с тем же числом строк, что и в матрице a.
c является действительным скаляром и возвращает угол между столбцами матриц a и b. Малое значение c свидетельствует о
почти линейной зависимости a и b
>>A = [1, 2, 3]'
B = [1, 1, -1]'
C = subspace(A, B)
A=
1
2
3
B=
1
1
-1
C = 1.5708
condeig
Возвращает собственные векторы, собственные значения и числа обусловленности всех собственных значений матрицы
e = condeig(a)
[c, d, e] = condeig(a)
a определяет матрицу.
c возвращает собственный вектор матрицы a. c представляет квадратную матрицу того же размера, что и a.
d возвращает собственные значения матрицы a. d является диагональной матрицей.
13
e возвращает числа обусловленности всех собственных значений матрицы a
>>A = [1+2i, 4i; -3-6i, -5i]
E = condeig(A)
A=
1 + 2i
-3 - 6i
0 + 4i
0 - 5i
E=
1.4007
1.4007
eig
Вычисляет собственные значения и собственные векторы для вещественных или комплексных квадратных матриц. eig(a) решает стандартную задачу ax = lambda*x. eig(a, b) решает общую задачу ax = lambda*bx
ev = eig(a)
ev = eig(a, b)
[evec, evdiag] = eig(a)
[evec, evdiag] = eig(a, b)
a определяет квадратную матрицу, обусловленные матрицы которой являются также квадратными.
b определяет матрицу того же размера, что и a. При определении b LabVIEW вызывает функцию qz.
ev возвращает собственные значения матрицы a или обобщенные собственные значения a и b. ev является вектором.
evec возвращает квадратную матрицу, столбцы которой являются нормированными собственными векторами матрицы a или
нормированными обобщенными собственными векторами матриц a и b.
evdiag возвращает матрицу того же типа, что и матрица a с элементами ev на диагонали
>>% Eigenvalues
A = [2, -1; 11, 4]
C = eig(A)
A=
2
11
% Compute generalized
eigenvalues and check results
B = [3, 2; -9, -1]
[EVEC, EVDIAG] = eig(A, B)
B=
3
-9
-1
4
C=
2
-1
3 + 3.1623i
3 - 3.1623i
EVEC =-0.26448 + 0.23786i
0.95926 + 0.040743i
EVDIAG =
-0.26448 - 0.23786i
0.95926 - 0.040743i
-0.7 + 0.88129i 0 + 0i
0 + 0i
-0.7 - 0.88129i
balance
Функция масштабирует матрицу общего вида для повышения точности расчета собственных значений и собственных векторов.
LabVIEW рассчитывает balance(a) используя следующее равенство: b = t\a*t
[t, b] = balance(a)
a – входная матрица.
b возвращает уравновешенную матрицу a, такую, что нормы строк и столбцов становятся примерно одинаковыми.
t возвращает перестановку диагональной матрицы
>>A = [1000, 1000; 0.001, 1];
[T, B] = balance(A)
T=
512
0
0
1
B=
1000
0.512
1.9531
1
Функции, выполняющие различные разложения:
chol
Рассчитывает треугольный множитель Холецкого положительно определенной эрмитовой матрицы
c = chol(a)
a определяет квадратную положительно определенную эрмитову матрицу.
c возвращает треугольный множитель Холецкого матрицы a.
Матрица c удовлетворяет уравнению c'*c = a. c – квадратная матрица того же размера, что и a
>>A = [23, -22, -14; -22, 144, -14; -14, -14, 35]
C = chol(A)
D = C'*C
A=
23
-22
-14
-22
144
-14
-14
-14
35
C = 4.7958 -4.5873 -2.9192
0
11.089 -2.4702
0
0
4.514
D=
23
-22
-14
-22
144
-14
-14
-14
35
cholupdate
Выполняет разложение Холецкого матрицы с увеличенным или уменьшенным на 1 рангом. С помощью этой функции LabVIEW
выполняет разложение Холецкого эффективнее, чем с помощью функции chol.
[R1, p] = cholupdate(R, x, op)
R определяет квадратную матрицу. LabVIEW использует только диагональную и верхнюю треугольную часть R для выполнения матрицы с увеличенным или уменьшенным на 1 рангом. R представляет двумерный массив действительных или комплексных чисел с плавающей запятой двойной точности.
x определяет вектор-столбец. x является массивом действительных или комплексных чисел с плавающей запятой двойной
точности и должен иметь длину, соответствующую матрице R.
op определяет увеличение или уменьшение на 1 ранга. op является строкой, которая принимает следующие значения:
'+' (по умолчанию) – выполняет разложение Холецкого матрицы с увеличенным на 1 рангом, R'R+xx'.
'-' – выполняет разложение Холецкого матрицы с уменьшенным на 1 рангом, R'R-xx'.
R1 возвращает разложение Холецкого. R1 является двумерным массивом действительных или комплексных чисел с плавающей запятой двойной точности и представляет верхнюю треугольную матрицу.
p возвращает информацию о разложение Холецкого calculation когда op is '-'. p возвращает 0 если R1 является разложением
Холецкого R'R-xx'. p больше 0 если функция cholupdate не выполняется и R1 является разложением Холецкого R'R. p возвращает 1 если cholupdate не выполняется поскольку R'R-xx' не является положительно определенной. p возвращает 2 если cholupdate не выполняется поскольку R не является действительным разложение Холецкого, т.е. R'R не является положительно
определенной. p является 32-битовым целым
14
>>R = rand(2)
X = rand(2, 1)
[R1, P] = cholupdate(R, X, '-')
R = 0.75444
0.50498
0.45195
0.52939
X = 0.041373
0.27944
R1 = 0.7533
0
0.43728
0.46391
P=
0
lu
Разлагает квадратную матрицу на верхнюю и нижнюю треугольные матрицы, используя разложение Гаусса
l = lu(a)
[l, u] = lu(a)
[l, u, p] = lu(a)
a определяет квадратную матрицу.
l возвращает переставленную нижнюю треугольную матрицу. Если задано, что [l, u, p] = lu(a), l возвращает нижнюю треугольную
матрицу с 1 на диагонали, так что l*u = p*a. Если задано, что [l, u] = lu(a), l возвращает матрицу равную p'*m, где m – нижняя треугольная матрица с 1 на диагонали. Если задано, что l = lu(a), l возвращает точный нижний треугольник нижней треугольной матрицы и верхний треугольник u в этой же матрице. l является матрицей того же размера, что и a.
u возвращает верхнюю треугольную матрицу, для которой выполняется следующее равенство l*u = p*a. u – матрица имеет такой
же размер, что и матрица a.
p возвращает матрицу перестановки, такую что l*u = p*a.
Таким образом, LU-разложение p'*a выполняется без взаимной замены строк. Разложение играет роль ключевого шага для обращения матриц, вычисления определителя и решения системы линейных уравнений
>>A = [-6, 17; 3, 8]
[L, U] = lu(A)
B = L*U
A=
-6
3
17
8
L=
1
-0.5
0
1
U=
-6
0
17
16.5
B=
-6
3
17
8
qr
Выполняет QR-разложение входной матрицы с перестановкой или без перестановки по столбцу.
При QR-разложении матрицы a с перестановкой по столбцу рассчитываются матрицы q и r, а также матрица перестановок pm или
вектор поворота pv, такие, что q*r = a*pm или q*r = a(pv). LabVIEW выполняет такую перестановку a по столбцу, что диагональные
элементы r располагаются в порядке убывания
r = qr(a)
[q, r] = qr(a)
[q, r] = qr(a, 0)
[q, r, pm] = qr(a)
[q, r, pv] = qr(a, 0)
a определяет матрицу.
0 определяет, что LabVIEW вычисляет QR-разложение с экономичным размером, таким, что размер q равен m-х-min(m, n) и размер r равен min(m, n)-х-n, где a является матрицей m-х-n.
q возвращает прямоугольную или единичную матрицу QR-разложения a.
r возвращает верхнюю треугольную матрицу QR-разложения a.
pm возвращает матрицу перестановки QR-разложения a. pm является матрицей 32-битовых целых чисел со знаком.
pv возвращает вектор перестановки QR-разложения a. pv является вектором-строкой 32-битовых целых чисел со знаком.
QR-разложение иногда еще называется ортогонально-треугольным разложением. Оно может использоваться для решения системы линейных уравнений с числом уравнений большим числа неизвестных
>>A = rand(2)
[Q, R, P] = qr(A)
A=
0.94839
0.26431
0.85322
0.33491
Q=
-0.96329
-0.26847
-0.26847
0.96329
R = -0.98453
0
-0.91181
0.093557
P=
1
0
0
1
qz
Решает общую задачу собственных значений: ax = lambda*bx.
qz рассчитывает такие матрицы q и z, что q'*a*z = Ha и q'*b*z = Tb, где Ha – верхняя матрица Хессенберга и Tb – верхняя треугольная матрица. Пара (Ha, Tb) имеет те же собственные значения, что и пара (a, b). Отношения элементов alpha и beta являются решениями задачи собственных значений. Эти отношения допускают такие формы, как 0/0 или 1/0.
[q, z, alpha, beta, evec] = qz(a, b)
a определяет действительную квадратную матрицу. Для решения задач с собственными значениями для комплексных данных
необходимо использовать функцию eig.
b определяет действительную квадратную матрицу того же размера, что и a. Если b является невырожденной, то qz(a, b) эквивалентна решению задачи с собственными значениями: b^-1ax = lambda*x. Обобщенная форма обычно обеспечивает более точные
результаты.
q возвращает единичную матрицу такого же размера и типа, что и a.
z возвращает ортогональную матрицу такого же размера и типа, что и a.
alpha возвращает вектор. Если элемент в alpha равен нулю, b является вырожденной и связанные обобщенные собственные значения бесконечно велики. Соответствующие собственные значения для задачи bx = lambda*ax равны нулю.
beta возвращает вектор.
evec возвращает матрицу того же размера и типа, что и матрица a, столбцы которой являются обобщенными собственными векторами (a, b). Эти собственные векторы удовлетворяют следующему равенству: a*evec = b*evec*diagonal(alpha./beta).
>>A = [1, 4, -2.2; 31, 4.7, 6; 5.2, 3, -3]
B = [1, 2, 3; 4, 5, 6; 7, 8, 9]
[Q, Z, ALPHA, BETA, EVEC] = qz(A, B)
A=1
4 -2.2
31 4.7 6
5.2 3 -3
B=
Z=
ALPHA = -4.4022
-2.9885
1
0
0
0
0.89443
0.44721
1
4
7
2
5
8
3
6
9
23.858
Q=
-0.12309
-0.49237
-0.86164
EVEC = 0.32066
-0.28876
-0.059291
0.87034
-0.48887
0.99062
-0.0090883
-0.13632
-0.27985
-0.66024
-0.5
1
15
0
-0.44721
0.89443
BETA =
10.499
0.81683
0
-1
1
-0.5
schur
Возвращает разложение Шура квадратной матрицы. Разложение Шура квадратной матрицы A определяется выражением A =
CDCH, где D – матрица в форме Шура, а CH – комплексное транспонирование матрицы C
d = schur(a)
d = schur(a, option)
[c, d] = schur(a)
[c, d] = schur(a, option)
a определяет действительную или комплексную квадратную матрицу.
option определяет вид выполняемого разложения. option представляет строку, которая принимает следующие значения:
'complex' – формирует комплексное разложение матрицы a.
'real' – формирует действительное разложение матрицы a. LabVIEW размещает действительные собственные значения и комплексно-сопряженные пары собственных значений в диагональные блоки матрицы d размером 1 х 1 и 2 х 2.
d возвращает блочную верхнюю треугольную матрицу в действительной форме Шура, все элементы которой на главной диагонали
являются блоками 1 х 1 и 2 х 2. Если a является комплексной, d возвращает верхнюю треугольную матрицу в комплексной форме
Шура.
c возвращает ортогональную матрицу того же размера, что и a. Если a является комплексной, c возвращает единичную матрицу
>>A = [1, 2, 3; 4, 5, 6; 7, 8, 9]
[C, D] = schur(A)
A=1
4
7
2
5
8
3
6
9
C=
-0.23197
-0.52532
-0.81867
-0.88291
-0.23952
0.40387
0.40825
-0.8165
0.40825
D = 16.117
0
0
4.899
-1.1168
0
1.6063e-015
-5.5408e-016
-8.8739e-016
svd
Выполняет разложение по сингулярным значениям для вычисления четырех основных подпространств матрицы, а именно правого
и левого нуль-пространства и правого и левого полей изображения. Разложение по сингулярным значениям требует большого
объема вычислений, но является мощным алгоритмом для решения ряда задач, включая нахождение решений методом наименьших квадратов, нахождение 2-norm и условия оценки 2-norm, а также определение ранга матрицы. svd рассчитывает такие единичные матрицы u и v, что входная матрица эквивалентна u*s*conj(v')
sv = svd(a)
[u, s, v] = svd(a)
a определяет матрицу m-х-n .
sv возвращает сингулярные значения матрицы a. sv является действительным вектором с числом элементов min(m, n).
u возвращает ортогональную матрицу размером m-х-min(m, n).
s возвращает квадратную матрицу порядка min(m, n) с сингулярными значениями на главной диагонали и нулевыми значениями в
других элементах.
v возвращает ортогональную матрицу размером n-х-min(m, n)
>>A = [1, 2, 3, 4; 5, 6, 7, 8; 9, 0, 1, 2; 3, 4, 5, 6]
C = svd(A)
A=
1
5
9
3
2
6
0
4
3
7
1
5
4
8
2
6
C=
17.836
7.5561
0.89042
1.2864e-016
rref
Осуществляет приведение матрицы к треугольной форме, используя метод исключения Гаусса
[r, jb] = rref(a)
[r, jb] = rref(a, tol)
a определяет действительную или комплексную матрицу.
tol определяет допуск в ранговом критерии. tol является положительным числом. По умолчанию значение равно 1e16*m*n*infnorm, где m – число строк в a, n – число столбцов в a, и infnorm является нормой a типа inf-norm. Если tol меньше или
равен 0, LabVIEW использует значение по умолчанию.
r возвращает треугольную форму матрицы a.
jb возвращает вектор индексов, такой что r(1:len, jb) является единичной матрицей r-х-r, где len = length(jb), и a(:, jb) является основанием для диапазона a.
>>[R, JB] = rref([1, 2; 4, 1])
R=
1
0
0
1
JB =
1
2
hess
Приводит матрицу в форму Хессенберга и возвращает унитарную матрицу преобразований. Матрица в форме Хессенберга
имеет элементы, равные 0 ниже первой поддиагонали
[h, t] = hess(a)
a определяет квадратную матрицу.
h возвращает матрицу a в форме Хессенберга. h является матрицей того же размера, что и a. Если a – симметричная или эрмитова, то h является тридиагональной матрицей.
t возвращает унитарную матрицу преобразований. t является матрицей того же размера, что и a.
Матрица Хессенберга h удовлетворяет следующему унитарному преобразованию подобия: a = t*h*t' с t*t' = t'*t = eye(size(a))
>>A = [2, -4, 7; -1, 9, 0; -4, -7, 3]
[H, T] = hess(A)
A=
2
-1
-4
9
7
0
H=
1
0
0 -0.24254
0
-0.97014
16
C = T*H*T'
D = T*T'
T=
2
4.1231
0
-4
-5.8209
1.7059
1.8235
5.5783
-5.1765
10.294
C=
-7
3
66.332
-34.813
64.765
0 -0.97014
-34.813
39.927
-21.557
64.765
-21.557
-11.528
D=
69
-30.559
46.809
0.24254
-30.559
46.706
-50.176
46.809
-50.176
109.29
pinv
Рассчитывает псевдообратную матрицу. Матрица A+ размером m-х-n является псевдообратной по отношению к матрице A если A+
удовлетворяет следующим четырем условиям Мура-Пенроуза:
A A+ A = A;
A+ A A+ = A+;
A A+ является симметричной матрицей;
A+ A является симметричной матрицей
c = pinv(a)
c = pinv(a, tol)
a – вещественная или комплексная прямоугольная матрица.
tol определяет допуск. Число сингулярных значений, превышающих tol, является рангом матрицы a. tol представляет действительное число. По умолчанию значение равно -1.
Если tol отрицательно, LabVIEW устанавливает допуск, используя следующее выражение:
tol = max(m, n)*||A||*eps, где A – входная матрица, m, n – число строк и столбцов в матрице A,
||A|| – норма 2-norm матрицы A, и eps – самое наименьшее число с плавающей запятой,
такое что 1+eps>1. eps определяется следующим соотношением: eps = 2^(-52) = 2,22e-16.
c возвращает псевдообратную матрицу a. c является матрицей
>>A = [1, 0, 1; 0, 0, 4]
C = pinv(A)
A=
1
0
0
0
1
4
C=
1
0
-2.6827e-017
-0.25
0
0.25
diag
Вычисляет диагональную матрицу или диагональ матрицы. diag(a, 0) эквивалентно diag(a)
c = diag(a)
c = diag(a, b)
a определяет вектор или матрицу.
b определяет диагональ матрицы a. b является целым.
c возвращает диагональную матрицу или диагональ матрицы. c является вектором или матрицей. Если a является матрицей,
diag(a) возвращает вектор-столбец, содержащий диагональ a и diag(a, b) возвращает вектор-столбец, содержащий b-ю диагональ a.
Если a является вектором длины n, diag(a, b) является квадратной матрицей размером n+abs(b) с b-й диагональю, определяемой a
>>A = [1, 0, 0; 0, 2, 0; 0, 0, 3]
C = diag(A)
A=
1
0
0
0
2
0
0
0
3
C=
1
2
3
null
Порождает ортонормированный базис для нуль-пространства матрицы. Нуль-пространство матрицы A состоит из всех векторов x,
таких, что Ax = 0
c = null(a)
c = null(a, 'r')
a определяет матрицу.
'r' порождает рациональный базис.
с возвращает базис для матрицы a. c является матрицей
>>A = [1, 2, 3; 4, 5, 6]
C = null(A)
A=
1
4
2
5
3
6
C=
0.40825
-0.8165
0.40825
C=
-0.38632
-0.92237
orth
Создает ортонормированный базис для матрицы
c = orth(a)
a определяет матрицу.
с возвращает ортонормированный базис для матрицы a. c является матрицей
>>A = [1, 2, 3; 4, 5, 6]
C = orth(A)
A=
1
4
2
5
3
6
-0.92237
0.38632
polyvalm
Оценивает полином при заданных значениях матрицы
c = polyvalm(a, b)
17
a – коэффициенты по степеням убывания оцениваемого полинома. a является вектором.
b – значение, для которого необходимо оценить a. b представляет квадратную матрицу.
с возвращает оцениваемые значения a в соответствии со следующим выражением: c = a[1]*b^n+ ... +a[n]*b+a[n+1]*I, где n – степень a. c является матрицей
>>A = [1, 1, 1]
B = [1, 2; 3, 4]
C = polyvalm(A, B)
A= 1
1
1
B=
1
3
2
4
C=
9
18
12
27
compan
Возвращает сопровождающую матрицу для полинома
c = compan(a)
a – вектор, определяющий коэффициенты полинома в порядке убывания степеней. Первый элемент в a является старшим коэффициентом полинома, который равен единице для нормированного полинома. Следовательно, входной вектор размером n порождает сопровождающую матрицу размером (n-1) х (n-1).
c возвращает сопровождающую матрицу a. Размер c равен порядку матрицы a
>>A = [1, 2, 3, 4]
C = compan(A)
A= 1
2
3
4
C=
-2
1
0
-3
0
1
-4
0
0
2.2. Решение обыкновенных дифференциальных уравнений и систем
Дифференциальным уравнением n-го порядка называется соотношение вида:
F ( t , x , x , x ,... x ( n ) )  0 .
Решение дифференциального уравнения – функция x ( t ) обращает уравнение в тождество.
Системой дифференциальных уравнений n-го порядка называется система вида:
 x'  f ( t , x , x ,... x ),
1 2
n
 '1 1
 x 2  f2 ( t , x1 , x 2 ,... x n ),

...

 x'  f ( t , x , x ,... x ).
n
1 2
n
 n
Ее решением является вектор
 x1 ( t ) 


 x2 ( t )
x( t )  

 ... 
 x n ( t )


, который обращает уравнения системы в тождества. Для одно-
значного определения решения необходимо задать дополнительные начальные или граничные условия.
Для решения дифференциальных уравнений и систем в MathScript предусмотрены следующие функции [2]:
Имя
функции
Тип
Порядок
задачи
точности
Метод решения
Рекомендации по использованию
ode113
Нежесткая
От низкого до
высокого
Многошаговый Адамса
При высоких требованиях к точности или необходимости применения эффективного алгоритма
ode15s
Жесткая
От низкого до
среднего
Гира
Если ode45 работает медленно изза жесткости задачи
ode23
Нежесткая
Низкий
Явный Рунге-Кутта 2-3-го порядка
При невысоких требованиях к точности или решении умеренно жестких задач
ode23s
Жесткая
Низкий
Одношаговый с применением формулы Розенброка 2-го порядка
При невысоких требованиях к точности для решения жестких систем
с постоянной матрицей массы
ode23tb
Жесткая
Низкий
Неявный Рунге-Кутта 2-3-го порядка
При невысоких требованиях к точности для решения жестких задач
ode45
Нежесткая
Средний
Явный Рунге-Кутта 4-5 порядка
Применим в большинстве случаев.
Рекомендуется использовать для
первой попытки
Эти функции имеют одинаковый синтаксис ode…=(fun,times,y0 [options]), где
fun – вектор-функция для вычисления правой части уравнения или системы уравнений;
times – вектор, описывающий интервал интегрирования дифференциального уравнения или
y0 – вектор начальных условий системы дифференциальных уравнений.
В качестве примера ниже приведены справочные данные по одной из функций – ode45.
системы;
ode45
Использует программу решения ОДУ Рунге-Кутта 45 для определения значений y в системе ОДУ
[t, y] = ode45(fun, times, y0)
18
fun является строкой и определяет имя функции, которая описывает систему ОДУ. Функция должна иметь следующую форму:
function dy = fun(t, y).
times определяет способ задания значений времени – с помощью конечных точек для интервала времени в виде [0 20], или с
помощью моментов времени, в которые производится аппроксимация значений y, в виде 1:20. Если определяются только конечные точки, LabVIEW возвращает моменты времени, в которые оцениваются значения y. Если же задаются моменты времени, LabVIEW аппроксимирует значения y, используя точность третьего порядка. times является вещественным вектором двойной точности, значения которого должны быть строго монотонными.
y0 определяет значение y в начальный момент времени. y0 – вещественный вектор двойной точности.
t возвращает значения времени, в которые производится оценка значений y. t – вещественный вектор двойной точности.
y возвращает аппроксимируемые значения в виде вещественной матрицы двойной точности
Таким образом, для решения ОДУ или системы ОДУ необходимо сформировать соответствующую функцию. Примеры таких функций приведены ниже.
du
 a1u  cos( u * t ) , с начальным условием u(0)=0.1. и
dt
запись функции: function y = model1(t, x)
y = – 0.5*x+cos(x*t);
1. ОДУ первого порядка
1.1. Определение и
коэффициентом
a1 =0.5.
1.2. Вызов функции решения ОДУ: [t, y] = ode45(‘model1’, [0 10], 0.1) (вводится в командном окне);
1.3. Результат решения (выводится на графике в окне переменных) (рис. 2.1).
Рис. 2.1. Результат решения ОДУ первого порядка
(n)
( n 1 )
 ...  a2u  a1u  b1v для решения в MathScript должно быть преобразовано в
2. ОДУ n-го порядка u  anu
систему n линейных уравнений 1 порядка с помощью выбора соответствующих линейно независимых переменных. Наиболее простое каноническое описание получается в том случае, когда в качестве таких переменных
выбираются выходная переменная u и ее производные до (n-1) включительно.
x1  u , x2  u, ... xn  u( n1 )
Тогда система уравнений будет выглядеть следующим образом:
 x'  x 2
 1
 x'  x 3
 2
...
 '
 x n  b1v  a1 x1  a2 x 2  ....  an x n .
u  x
1

второго порядка u  a2u  a1u  0 с
Выберем в качестве примера ОДУ
начальными условиями
и коэффициентами a2  0.5 , a1  1 . Это ОДУ будет описывать свободной движение системы
второго порядка при заданных начальных условиях.
2.1. Определение и запись функции: function y=model2(t,x)
u( 0 )  0.1, u( 0 )  0.1
y(1)=x(2);
y(2)=–0.5*x(2) – x(1);
2.2. Вызов функции решения системы ОДУ: [t, y] = ode45(‘model2’, [0 10], [0.1, 0.1])
Для разделения двумерного массива y, содержащего временные зависимости переменной u и ее производной, на два одномерных целесообразно добавить следующие операторы: y1=y(:,1), y2=y(:,2). Полученные массивы
могут быть выведены на график относительно оси времени (рис. 2.2) или в виде XY-графика (рис. 2.3). В последнем случае график представляет фазовый портрет системы. Для построения двух графиков относительно
оси времени необходимо выделить соответствующие переменные в окне переменных (с помощью «горячей»
клавиши <Ctrl>) и указать графическую форму представления (флажок Graphical First?) и в выпадающем меню
выбрать соответствующий тип графика.
19
Рис. 2.2. Вид временного изменения переменной и
ее производной
Рис. 2.3. Фазовая траектория системы второго порядка
В общем виде, при неравенстве нулю правой части ОДУ его решение будет описывать процесс на выходе
системы при подаче на нее внешнего воздействия. На рисунке 2.4 приведен пример временной функции, являющейся решением ОДУ u  a2u  a1u  sin( 2 * t ) . С помощью решения этого уравнения можно показать различие в точности решения ОДУ функциями ode45 и ode23 (Рис. 2.5).
Рис. 2.4. Решение ОДУ второго порядка с ненулевой
правой частью
Рис. 2.5. Сравнительная точность методов решения
ОДУ ode45 и ode23
3. Решение жестких систем дифференциальных уравнений с помощью функций ode15s и ode23s .
Система дифференциальных уравнений n-го порядка dx / dt  Bx называется жесткой, если выполняются следующие условия:
1. действительные части всех собственных значений матрицы B отрицательны: (Re( k )  0 , k  0 ,1,..., n  1 ) ;
2.
величина
s
max Re( k )
min Re( k ) 0  k  n 1
, называемая числом жесткости системы, велика.
Найдем решение для следующей системы:

 100


 dX   10.5


 dt   40
  95



156
107
 10
4
 65  55.5
 152  102
102 
 1 



8 
 2 
X ; X(0 )  
.
 41 
 1.5 



 99 
 1
3.1. Проверка условия 1:

-5.5309e+001 + 0.0000e+000i
-4.3467e+000 + 2.8169e+000i
-4.3467e+000 - 2.8169e+000i
-4.9769e-001 + 0.0000e+000i
3.2. Проверка условия 2: s=111,1
Вывод – система жесткая.
3.3. Определение и запись функции: function y=model3(t,x)
B=[100 156 107 102; -10.5 -10 -4 -8; -40 -65 -55.5 -41; -95 -152 -102 -99]
y=B*x;
системы ОДУ: [A, B] = ode15s(‘model3’, [0 5], [1; 2; 1.5; –1])
3.4. Вызов функции решения
Результаты решения жестких систем дифференциальных уравнений представлены на рисунке 2.6.
20
Рис. 2.6. Результаты решения жестких систем дифференциальных уравнений
2.3. Операции с полиномами
Для описания полинома n-ой степени a( x )  a1 x n  a 2 x n1  ... a n x  a n1 в MathScript используется
вектор, содержащий коэффициенты полинома a  [ a( 1 ) a( 2 ) a( n ) a( n  1 )] , расположенные в порядке убывания степеней х. Отсутствующие степени заменяются нулями.
Ниже приведены функции, выполняющие различные действия с полиномами.
poly
Генерирует полином с корнями, представленными входным вектором или рассчитывает характеристический полином входной
матрицы. Расчет полиномов и отыскание корней и являются обратными операциями.
p = poly(z)
z определяет действительный или комплексный вектор или матрицу. Если z является матрицей, то она должна быть квадратной.
p возвращает коэффициенты в порядке убывания степеней полинома, имеющего корни z. Если z является матрицей, p возвращает коэффициенты в порядке убывания степеней характеристического полинома z. p является действительным или комплексным вектором
>>Z = [1, 2, 3, 4];
P = poly(Z)
P = 1.00000e+000
-1.00000e+001
3.50000e+001
-5.00000e+001 2.40000e+001
roots
Рассчитывает корни полинома.
c = roots(a)
a определяет коэффициенты перед степенями полинома, для которого рассчитываются корни, в порядке убывания степеней. a является вектором.
с возвращает корни полинома a. c является вектором действительных или комплексных чисел
A = [5, 4, 3, 2, 1]
C = roots(A)
C=
1.3783e-001 + 6.7815e-001i
1.3783e-001 - 6.7815e-001i
-5.3783e-001 + 3.5828e-001i
-5.3783e-001 - 3.5828e-001i
polyval
Оценивает полином при заданных значениях. В отличие от polyvalm эта функция выполняется с элементами матрицы.
c = polyval(a, b)
a – коэффициенты перед степенями оцениваемого полинома в порядке убывания степеней. a является вектором.
b – значение, для которого необходимо оценить a. b представляет квадратную матрицу.
с возвращает оцениваемые значения a в соответствии со следующим выражением: c = a[1]*b.^n+ ... +a[n]*b+a[n+1]*I, где n
– степень a, I – матрица, составленная из единиц. c является матрицей такого же размера, что и а
>>A = [1, 1, 1];
B = [1, 2; 3, 4];
C = polyval(A, B)
C = 3.00000e+000
1.30000e+001
7.00000e+000
2.10000e+001
>>A = [1, 1, 1];
B = [1, 2; 3, 4];
C = polyvalm(A, B)
C=
9.00000e+000
1.80000e+001
1.20000e+001
2.70000e+00
polyint
Возвращает интеграл полинома.
c = polyint(a)
c = polyint(a, b)
a является вектором и определяет коэффициенты перед степенями интегрируемого полинома в порядке убывания степеней.
b является скаляром и определяет постоянную интегрирования. Если b не задан, LabVIEW устанавливает для него нулевое
значение.
21
c является вектором и возвращает коэффициенты перед степенями проинтегрированного полинома в порядке убывания степеней
>>A = [1, 2, 3, 4];
C = polyint(A)
C = 2.50000e-001
6.66667e-001
1.50000e+000
4.00000e+000
0.00000e+000
residue
Рассчитывает дробно-рациональное представление двух полиномов или преобразует заданное дробно-рациональное
представление в исходное полиномиальное представление.
LabVIEW рассчитывает a и b при отсутствии кратных корней с помощью следующего соотношения:
bs/as = (r1/(s-p1)) + (r2/(s-p2)) + ... + (rn/(s-pn)) + ks
где s – степень и n – число элементов в дробно-рациональном представлении
Если кратные корни существуют, т.е. если pj = ... = pj+m-1 , где j – индекс элемента и m – кратность, то дробно-рациональное
представление включает следующие члены: (rj/(s-pj)) + (rj+1/(s-pj))2 + ... + (rj+m-1/(s-pj))m.
[b, a] = residue(r, p, k)
[r2, p2, k2] = residue(b2, a2)
r определяет остатки дробно-рационального представления и является действительным или комплексным вектором.
p определяет полюсы дробно-рационального представления и является действительным или комплексным вектором.
k определяет коэффициенты перед степенями частного от деления полиномов a и b в порядке убывания степеней.
b2 определяет коэффициенты перед степенями полинома числителя в порядке убывания степеней.
a2 определяет коэффициенты перед степенями полинома знаменателя в порядке убывания степеней.
b возвращает коэффициенты перед степенями полинома числителя в порядке убывания степеней.
a возвращает коэффициенты перед степенями полинома знаменателя в порядке убывания степеней.
r2 возвращает остатки дробно-рационального представления и является действительным или комплексным вектором.
p2 возвращает полюсы дробно-рационального представления и является действительным или комплексным вектором.
k2 возвращает коэффициенты перед степенями частного от деления полиномов a2 и b2 в порядке убывания степеней
>>B = [1, 2, 3, 4];
A = [1, 1];
[R, P, K] = residue(B, A)
R = 2.00000e+000
P = -1.00000e+000
K = 1.00000e+000
1.00000e+000
2.00000e+000
polyeig
Решает задачу собственных значений полинома степени n: (a0+lambda*a1+...+lambda^n*an)*x = 0. Могут быть задано неограниченное число матриц. Все матрицы должны быть квадратными и должны иметь одинаковый размер.
[x, eig] = polyeig(a0, a1, ... , an)
a0 определяет действительную или комплексную матрицу.
a1, …, an определяют действительные или комплексные матрицы того же размера, что и a0.
x возвращает матрицу, столбцы которой представляют собственные векторы входных матриц.
eig является вектором и возвращает собственные значения входных матриц
>>A0 = [1, 2; 3, 4];
A1 = [2, 1; 1, 0];
A2 = [-1, -1; 0, 2];
[X, EIG] = polyeig(A0, A1, A2)
X=
EIG = 2.6590e+000 - 1.7764e-016i
-3.2948e-001 - 8.0225e-001i
-3.2948e-001 + 8.0225e-001i
5.0000e-001 + 1.4653e-017i
-9.5233e-001 + 6.6173e-002i
2.9709e-001 - 2.0643e-002i
-2.2335e-002 - 7.4473e-001i
4.1322e-001 + 5.2357e-001i
2.5345e-001 + 7.0064e-001i
1.9141e-001 - 6.3893e-001i
-7.8808e-001 - 4.4776e-002i
6.1295e-001 + 3.4826e-002i
polyfit
Рассчитывает полином заданной степени, который аппроксимирует входные данные с помощью метода наименьших квадратов.
[p, s] = polyfit(x, y, n)
[p, s, mu] = polyfit(x, y, n)
x является матрицей и определяет х-координаты аппроксимируемых данных.
y является матрицей такого же размера, как у х и определяет y-координаты аппроксимируемых данных
n определяет степень полинома, который используется для аппроксимации x и y. n является положительным целым и должна
быть меньше длины x.
p возвращает коэффициенты перед степенями аппроксимирующего полинома в порядке убывания степеней. p представляет
матрицу.
s возвращает множитель Холецкого матрицы Вандермонда.
mu возвращает среднее значение и стандартное отклонение x. LabVIEW использует эти значения для нормализации x с целью улучшения аппроксимации. mu является вектором. Первый элемент mu содержит среднее значение, а второй – стандартное отклонение
conv
Рассчитывает свертку двух векторов или матриц. Расчет производится в соответствии с выражением
min( p , m )
Cp 

Ak B p  1  k , где m – длина вектора A, n – длина вектора B. Если A и B представляют векторы коэффициенk  max( 1 , p  1  n )
22
тов двух полиномов, то их свертка дает коэффициенты полинома, являющегося произведением этих полиномов.
c = conv(c1)
c = conv(c1, c2)
c1 и c2 определяют вектор или матрицу. Если c2 не задан, LabVIEW рассчитывает свертку c1 с c1.
c возвращает свертку c1 и c2. Если c1 и c2 являются векторами, c представляет вектор-свертку двух векторов и имеет ту же
ориентацию, что и c1. Если один из элементов c1 или c2 является матрицей, а другой является вектором, LabVIEW рассматривает вектор как вектор-столбец и производит свертку вектора с каждым столбцом матричного аргумента. Если оба элемента c1
и c2 являются матрицами, LabVIEW производит свертку каждого столбца c1 с c2 таким образом, что c представляет матрицу,
размер столбца которой равен произведению размеров столбцов c1 и c2
>>C1 = [1; 2; 3];
C2 = [3; 4];
C = conv(C1, C2)
C=
3.00000e+000
1.00000e+001
1.70000e+001
1.20000e+001
deconv
Производит операцию, обратную свертке, и находит коэффициенты полинома, являющегося результатом деления одного полинома на другой.
[c, d] = deconv(a, b)
a и b определяют векторы.
c является вектором и возвращает частное от деления a и b.
d является вектором и возвращает остаток от деления a и b. LabVIEW рассчитывает деконволюцию используя следующее равенство : a = conv(b, c)+d. Для формирования c и d LabVIEW производит полиномиальное деление a и b
>>A = [3, 10, 17, 12];
B=[3 4];
[C, D] = deconv(A, B)
C = 1.00000e+000
D = 0.00000e+000
2.00000e+000
0.00000e+000
3.00000e+000
0.00000e+000
0.00000e+000
2.4. Статистические функции
В наборе статистических функций MathScript можно выделить функции расчета точечных статистических
характеристик (среднего значения, медианы, дисперсии и среднеквадратичного отклонения), корреляционных
параметров, значений гистограмм и случайных чисел с определенны законом распределения. Именно в таком
порядке они и рассматриваются ниже.
mean
Вычисляет среднее значение
c = mean(a)
c = mean(a, b)
a определяет вектор или матрицу.
b определяет размерность a, по которой необходимо рассчитывать среднее значение, если a является матрицей.
b является скаляром, который принимает следующие значения.
1 (по умолчанию) – рассчитывает среднее по столбцам;
2 – рассчитывает среднее по строкам.
c возвращает среднее значение a. Если a является вектором, c возвращает среднее значение всех элементов a. Если a является матрицей, c возвращает вектор-строку средних значений по столбцам или вектор-столбец средних значений по строкам в
a. c является скаляром или вектором
Функция median вычисляет медиану и имеет синтаксис аналогичный синтаксису функции mean
std
Возвращает стандартное отклонение вектора или матрицы. Для матрицы эта функция выполняется по столбцам.
y = std(x)
y = std(x, w)
x определяет вектор или матрицу.
w определяет вес и является матрицей. w может находиться в одном из трех состояний:
1. w является матрицей, имеющей такой же размер, что и x. Все элементы в w должны быть больше 0. LabVIEW нормирует
w так, что сумма всех элементов w равна 1.
2. w является матрицей, имеющей только один элемент, 1. Входная матрица не имеет веса. LabVIEW нормирует выход на
длину входной матрицы.
3. w является матрицей, имеющей только один элемент, 0, или является пустой матрицей. Входная матрица не имеет веса.
LabVIEW нормирует выход на длину входной матрицы минус один.
y возвращает стандартное отклонение x. y является скаляром или вектором
Функция var возвращает дисперсию (квадрат стандартного отклонения) вектора или матрицы и по синтаксису идентична функции std.
Следующие функции рассчитывают коэффициенты корреляции, ковариационную матрицу и кросс-корреляцию
corrcoef
Рассчитывает коэффициенты корреляции
23
r = corrcoef(x)
r = corrcoef(x, y)
[r, p, rlo, rup] = corrcoef(x, 'alpha', a, 'rows', s)
[r, p, rlo, rup] = corrcoef(x, y, 'alpha', a, 'rows', s))
x определяет результат наблюдения для каждой переменой. При определении r = corrcoef(x), x может быть действительным
или комплексным. При определении [r, p, rlo, rup] = corrcoef(x, 'alpha', a, 'rows', s), x должен быть действительным. x может
быть вектором или матрицей. Если x является вектором, каждый элемент x является результатом наблюдения. Если x является матрицей, каждая строка в x является результатом наблюдения, и каждый элемент в строке является данными для этого
наблюдения.
y является массивом такой же длины, что и х. Он определяет значения данных для каждого наблюдения в x, если x является
вектором. y не может быть задан если x является матрицей.
'alpha' сообщает LabVIEW, что следующим входным параметром в списке является a.
a определяет доверительную вероятность 1-a и является действительным числом в интервале [0, 1]. По умолчанию значение
равно 0,05.
'rows' сообщает LabVIEW, что следующим входным параметром в списке является s.
s определяет способ обработки значений NaN в x. s является строкой, которая принимает следующие значения:
'all' (по умолчанию) – использует все данные для расчета коэффициентов корреляции.
'complete' – использует только строки без значений NaN для расчета коэффициентов корреляции.
'pairwise' – использует только строки без значений NaN в i-м и j-м столбце x для расчета (i, j)-го элемента r.
r возвращает коэффициенты корреляции.
p является матрицей и возвращает значения вероятности p для нулевой гипотезы.
rlo и rup являются матрицами и возвращают нижнюю и верхнюю границы для доверительного интервала каждого коэффициента
cov
Рассчитывает ковариационную матрицу входных элементов. c = cov(x, y) и c = cov(x, y, 1) эквивалентны cov([x(:), y(:)])
c = cov(x)
c = cov(x, option)
c = cov(x, y)
c = cov(x, y, option)
x определяет действительную или комплексную матрицу. Каждый столбец x представляет один вектор наблюдаемых выборок
одной переменной. Каждая строка x представляет результат наблюдения для каждой переменной. Если x имеет только одну
строку, LabVIEW возвращает нулевую матрицу.
y определяет действительную или комплексную матрицу того же размера, что и x.
option определяет вариант нормирования x на n или на n-1, где n – длина x, если x – вектор, или число строк x, когда x – матрица. option является целым числом, которое принимает следующие значения:
0 (по умолчанию) – нормирует x на n-1.
1 – нормирует x на n.
c возвращает ковариационную матрицу. Если задано c = cov(x, y) или c = cov(x, y, 1), c возвращает матрицу 2-х-2
xcorr
Рассчитывает кросс-корреляцию входов
c = xcorr(a)
c = xcorr(a, l)
c = xcorr(a, option)
c = xcorr(a, l, option)
c = xcorr(a, b)
c = xcorr(a, b, l)
c = xcorr(a, b, option)
c = xcorr(a, b, l, option)
[c, d] = xcorr(a)
[c, d] = xcorr(a, l)
[c, d] = xcorr(a, option)
[c, d] = xcorr(a, l, option)
[c, d] = xcorr(a, b)
[c, d] = xcorr(a, b, l)
[c, d] = xcorr(a, b, option)
[c, d] = xcorr(a, b, l, option)
a определяет вектор или матрицу.
b определяет вектор.
l управляет длиной кросс-корреляции. Если a – вектор длины n, c = xcorr(a, l) возвращает вектор длины 2*l+1. LabVIEW дополняет l нулями когда l больше или равен n.
option определяет метод нормирования, который должен использоваться для расчета кросс-корреляции между a и b. option
является строкой, которая принимает следующие значения.
'biased' – применяет смещенное нормирование.
'coeff' – применяет такое нормирование, что автокорреляция равна 1, когда первый вход равен 0.
'none' (по умолчанию) – не применяет нормирования.
'unbiased' – применяет несмещенное нормирование.
c возвращает кросс-корреляцию между a и b. Если a является матрицей, c = xcorr(a) возвращает кросс-корреляцию всех комбинаций столбцов a. c является вектором или матрицей.
d возвращает индексы кросс-корреляции. Если определено значение l, d находится в диапазоне [-l, -l+1, ..., 0, ..., l-1, l]. d явля-
24
ется вектором
hist
Подсчитывает количество данных, которые попадают в заданные интервалы. Если выход не определен, LabVIEW возвращает
график гистограммы
hist(x)
hist(x, c)
hist(x, m)
n = hist(x, c)
[n, ctr] = hist(x)
[n, ctr] = hist(x, m)
x является матрицей и определяет значения данных.
c является матрицей и определяет центры всех интервалов, на которые разделяется диапазон x. Элементы c должны располагаться в порядке возрастания.
m определяет число равномерно расположенных интервалов, на которые разделяется диапазон x. m является положительным
целым. По умолчанию значение m равно 10.
n возвращает число элементов, которые попадают в каждый интервал. n представляет массив целых чисел.
ctr возвращает центры всех интервалов, если матрица c не определена. ctr является массивом
histc
Подсчитывает количество данных, которые попадают между границами заданных интервалов
n = histc(x, edges)
[n, bin] = histc(x, edges)
x является матрицей и определяет значения данных. Если x является двумерной матрицей, histc выполняет подсчет гистограммы по столбцам.
edges является матрицей и определяет границы всех интервалов. Элементы edges должны располагаться в порядке возрастания.
n возвращает количество значений, которые попадают между edges. n является массивом целых значений. n(i) показывает
количество значений в x, которые попадают в интервал [edges(i), edges(i+1)]. -inf и +inf являются действительными значениями
для edges. n(m) показывает количество значений в x, которые равны edges(m), где m – длина edges.
bin возвращает номер интервала, который содержит соответствующее значение x. bin(k) = j показывает, что x(k) находится в
интервале [edges(j), edges(j+1)] когда j<m-1, или x(k) = edges(m) когда j = m. Если bin(k) = -1, x(k) находится за границами диапазона. bin является массивом целых чисел той же длины, что и x
rand
Генерирует равномерно распределенные псевдослучайные числа в интервале [0, 1]. c = rand генерирует отдельное псевдослучайное число. Функция c = rand(a, b) эквивалентна c = rand([a, b]).
c = rand
c = rand(a)
c = rand(a, b)
c = rand([a, b])
a определяет число строк в c.
b определяет число столбцов в c. a и b являются положительными целыми числами.
c возвращает матрицу равномерно распределенных псевдослучайных чисел в интервале [0, 1] размером a-х-b. Если параметр
b не определен, c возвращает квадратную матрицу, имеющую размер a
Функция randn отличается от rand тем, что генерирует нормально распределенные псевдослучайные числа.
random
Генерирует случайные числа с заданным законом распределения. random(type, a, b, c) генерирует отдельное случайное число.
random(type, a, b, c, m) и random(type, a, b, c, n) генерируют матрицы размером m-х-m и n-х-n, соответственно. random(type, a, b, c,
m, n) и random(type, a, b, c, [m, n]) генерируют матрицу размером m-х-n.
r = random(type, a, b, c)
r = random(type, a, b, c, m)
r = random(type, a, b, c, n)
r = random(type, a, b, c, m, n)
r = random(type, a, b, c, [m, n])
type определяет вид распределения. type является строкой, которая принимает следующие значения:
Название распределения
'beta'
'bino'
'chi2'
'exp'
'f'
'gam'
'geo'
Вид распределения
Бета- распределение
Биномиальное распределение
Распределение хи-квадрат
Экспоненциальное распределение
F-распределение
Гамма-распределение
Геометрическое распределение
Число параметров
2
2
1
1
2
2
1
25
'hyge'
'logn'
'nbin'
'ncf'
'nct'
'ncx2'
'norm'
'poiss'
'rayl'
't'
'unid'
'unif'
'weib'
Гипергеометрическое распределение
Логнормальное распределение
Отрицательное биномиальное распределение
Нецентральное F-распределение
Нецентральное T-распределение
Нецентральное Хи-квадрат распределение
Нормальное распределение
Распределение Пуассона
Распределение Релея
T-распределение
Дискретное равномерное распределение
Непрерывное равномерное распределение
Распределение Вейбула
3
2
2
3
2
2
2
2
1
1
1
2
2
a, b и c определяют параметры распределения и являются числами или матрицами. Матрица должна иметь размер m-х-n.
m определяет число строк в r.
n определяет число столбцов в r. m и n являются положительными целыми.
r возвращает матрицу случайных чисел с типом распределения type размером m-х-n
randperm
Генерирует случайную перестановку натуральных чисел.
c = randperm(a)
a определяет положительное целое число.
c возвращает случайную перестановку целых чисел от 1 до a. с является вектором-строкой
detrend
Удаляет тренд из входных данных
y = detrend(x, option, break)
x определяет данные, из которых удаляется тренд. x является вектором или матрицей. Если x – матрица, LabVIEW исключает
тренд, проходя по столбцам.
option определяет вариант удаления тренда из x. option является строкой, которая принимает следующие значения:
'constant' – удаляются средние значения.
'linear' – удаляются линейные эффекты, при этом точки разрыва определяются параметром break.
break является вектором индексов x и определяет точки разрыва. При выборе варианта тренда 'constant' параметр break не
может быть задан. При выборе варианта 'linear' вектор break должен быть задан.
y возвращает x с удаленным трендом
nchoosek
Вычисляет биномиальный коэффициент
c = nchoosek(a, b)
a и b определяют целые числа.
c возвращает биномиальный коэффициент a по b. c является целым
2.5. Функции оптимизации
fminbnd
Рассчитывает минимум одномерной функции между двумя точками
xmin = fminbnd(fun, a, b)
[xmin, fval] = fminbnd(fun, a, b)
fun является строкой и определяет функцию, для которой рассчитывается минимум. Определяемая функция должна принимать и возвращать действительный скаляр двойной точности.
a и b определяют, соответственно, нижнюю и верхнюю границы отрезка линии, на котором необходимо найти минимум. a и b
являются действительными скалярами двойной точности.
xmin возвращает точку между a и b, в которой fun имеет минимальное значение.
fval возвращает значение fun , вычисленное в точке xmin. xmin и fval являются действительными скалярами двойной точности
fminsearch
Использует метод Downhill Simplex для расчета минимума n-мерной функции. Этот метод часто используется для минимизации функции с разрывами
xmin = fminsearch(fun, xstart)
[xmin, fval] = fminsearch(fun, xstart)
fun является строкой и определяет функцию, для которой рассчитывается минимум. Заданная функция должна принимать
вектор того же размера, что и xstart, и возвращать скаляр.
xstart определяет точку, в которой начинается поиск минимального значения fun. xstart является действительным вектором
двойной точности.
26
xmin возвращает точку, в которой fun имеет минимальное значение.
fval возвращает значение fun , вычисленное в точке xmin. xmin и fval являются действительными скалярами двойной точности
fminunc
Использует метод Quasi-Newton для расчета минимума n-мерной функции.
xmin = fminunc(fun, xstart)
[xmin, fval] = fminunc(fun, xstart
Все входные и выходные параметры идентичны соответствующим параметрам рассмотренной выше функции fminsearch
linprog
Использует симплекс-метод для расчета минимума линейной функции, определяемой следующим выражением: c'*x. LabVIEW
ограничивает вычисление опираясь на заданные входы
xmin = linprog(c, aineq, bineq)
xmin = linprog(c, aineq, bineq, aeq, beq)
xmin = linprog(c, aineq, bineq, aeq, beq, min, max)
[xmin, fval] = linprog(c, aineq, bineq)
[xmin, fval] = linprog(c, aineq, bineq, aeq, beq)
[xmin, fval] = linprog(c, aineq, bineq, aeq, beq, min, max)
[xmin, fval, lambda] = linprog(c, aineq, bineq)
[xmin, fval, lambda] = linprog(c, aineq, bineq, aeq, beq)
[xmin, fval, lambda] = linprog(c, aineq, bineq, aeq, beq, min, max)
c устанавливает вектор, который является частью линейной функции с рассчитываемым минимумом. c является действительным вектором двойной точности.
aineq определяет матрицу для линейных ограничений типа неравенства в соответствии со следующим выражением:
aineq*xmin <= bineq. aineq может быть []. aineq является действительной матрицей двойной точности.
bineq определяет вектор для линейных ограничений типа неравенства в соответствии со следующим выражением: aineq*xmin
<= bineq. bineq должен быть [] в случае если aineq []. bineq является действительным вектором двойной точности.
aeq определяет матрицу для линейных ограничений типа равенства в соответствии со следующим выражением: aeq*xmin =
beq. aeq can be []. aeq является действительной матрицей двойной точности.
beq определяет вектор для для линейных ограничений типа равенства в соответствии со следующим выражением: aeq*xmin =
beq. beq должен быть [] в случае если aeq []. beq является действительным вектором двойной точности.
min и max определяют нижний и верхний предел для вектора решения в соответствии со следующим выражением: min <= x <=
max. min и max являются действительными векторами двойной точности и могут быть [].
xmin возвращает точку, в которой fun имеет минимальное значение.
fval возвращает значение fun , вычисленное в точке xmin. xmin и fval являются действительными скалярами двойной точности.
lambda возвращает значения лямбда для вектора решения. lambda является действительным вектором двойной точности
quadprog
Рассчитывает минимум квадратичной функции, определенной следующим выражением: 0.5*x'*q*x+c'*x. LabVIEW ограничивает
вычисление опираясь на заданные входы
xmin = quadprog(q, c, aineq, bineq)
xmin = quadprog(q, c, aineq, bineq, aeq, beq)
xmin = quadprog(q, c, aineq, bineq, aeq, beq, min, max)
[xmin, fval] = quadprog(q, c, aineq, bineq)
[xmin, fval] = quadprog(q, c, aineq, bineq, aeq, beq)
[xmin, fval] = quadprog(q, c, aineq, bineq, aeq, beq, min, max)
[xmin, fval, lambda] = quadprog(q, c, aineq, bineq)
[xmin, fval, lambda] = quadprog(q, c, aineq, bineq, aeq, beq)
[xmin, fval, lambda] = quadprog(q, c, aineq, bineq, aeq, beq, min, max)
q определяет матрицу, которая является частью квадратичной функции с рассчитываемым минимумом. q является действительной матрицей двойной точности.
Все остальные входные и выходные параметры идентичны соответствующим параметрам рассмотренной выше функции
linprog
fmincon
Использует метод последовательного квадратичного программирования для расчета минимума функции. LabVIEW ограничивает вычисление исходя из заданных входов
xmin = fmincon(fun, x0, aineq, bineq)
xmin = fmincon(fun, x0, aineq, bineq, aeq, beq)
xmin = fmincon(fun, x0, aineq, bineq, aeq, beq, min, max)
xmin = fmincon(fun, x0, aineq, bineq, aeq, beq, min, max, nonlinearfun)
[xmin, fval] = fmincon(fun, x0, aineq, bineq)
[xmin, fval] = fmincon(fun, x0, aineq, bineq, aeq, beq)
[xmin, fval] = fmincon(fun, x0, aineq, bineq, aeq, beq, min, max)
[xmin, fval] = fmincon(fun, x0, aineq, bineq, aeq, beq, min, max, nonlinearfun)
[xmin, fval, lambda] = fmincon(fun, x0, aineq, bineq)
27
[xmin, fval, lambda] = fmincon(fun, x0, aineq, bineq, aeq, beq)
[xmin, fval, lambda] = fmincon(fun, x0, aineq, bineq, aeq, beq, min, max)
[xmin, fval, lambda] = fmincon(fun, x0, aineq, bineq, aeq, beq, min, max, nonlinearfun)
fun является строкой и определяет функцию, для которой рассчитывается минимум. Для негладких функций функция fmincon
может не создать оптимальное значение.
x0 определяет точку, в которой начинается поиск минимального значения fun. x0 является действительным вектором двойной
точности.
nonlinearfun определяет функцию, которая обеспечивает дополнительные, обычно нелинейные, ограничения. Заданная функция должна принимать вектор и возвращать два вектора, nonlinineq и nonlineq. LabVIEW находит такое решение, что nonlinineq
<= 0 и nonlineq = 0. nonlinearfun является строкой.
Все остальные входные и выходные параметры идентичны соответствующим параметрам рассмотренной выше функции
linprog
Список литературы
1.
Кривлёв А.В. Основы компьютерной математики с использованием системы MATLAB. М.: ЛексКнига, 2005. – 496 с. с ил.
2.
Новгородцев А.Б. Расчет электрических цепей в MATLAB: Учебный курс. –СПб Питер, 2004. – 250 с.:
ил.
28