1@c ------------------------------------------------------------------ 2@chapter Обработка данных 3@nav{} 4 5@ifset UDAV 6В данной главе описываются команды для работы с массивами данных. Они включают команды для выделения памяти и изменения размера данных, чтения данных из файла, численного дифференцирования, интегрирования, интерполяции и пр., заполнения по текстовой формуле и т.д. Класс позволяет работать с данными размерности не более 3 (как функции от трёх переменных -- x,y,z). Массивы которые могут быть созданы командами MGL отображаются Small Caps шрифтом (например, @sc{dat}). 7@end ifset 8 9@ifclear UDAV 10В данной главе описываются классы @code{mglData} и @code{mglDataC} для работы с массивами действительных и комплексных данных, определённые в @code{#include <mgl2/data.h>} и @code{#include <mgl2/datac.h>} соответственно. Оба класса являются наследниками абстрактного класса @code{mglDataA}, и могут быть использованы в аргументах всех функций рисования (см. @ref{MathGL core}). Классы содержат функции для выделения памяти и изменения размера данных, чтения данных из файла, численного дифференцирования, интегрирования, интерполяции и пр., заполнения по текстовой формуле и т.д. Классы позволяют работать с данными размерности не более 3 (как функции от трёх переменных -- x,y,z). По умолчанию внутреннее представление данных использует тип mreal (и dual=std::complex<mreal> для @code{mglDataC}), который может быть сконфигурирован как float или double на этапе установки указав опцию @code{--enable-double} (см. @ref{Installation}). Тип float удобен в силу меньшего размера занимаемой памяти и, как правило, достаточной для построения графиков точности. Однако, тип double имеет большую точность, что может быть важно, например, для осей с метками времени. Массивы которые могут быть созданы командами MGL отображаются Small Caps шрифтом (например, @sc{dat}). 11@end ifclear 12 13@menu 14* Public variables:: 15* Data constructor:: 16* Data resizing:: 17* Data filling:: 18* File I/O:: 19* Make another data:: 20* Data changing:: 21* Interpolation:: 22* Data information:: 23* Operators:: 24* Global functions:: 25* Evaluate expression:: 26* Special data classes:: 27@end menu 28 29@c ------------------------------------------------------------------ 30@external{} 31@node Public variables, Data constructor, , Data processing 32@section Переменные 33@nav{} 34 35@ifset UDAV 36MGL не поддерживает прямой доступ к элементам массива. См. раздел @ref{Data filling} 37@end ifset 38 39@ifclear UDAV 40@deftypecv {Variable} mglData @code{mreal *} a 41@deftypecvx {Variable} mglDataC @code{dual *} a 42Указатель на массив данных. Это одномерный массив. Например, матрица [nx x ny x nz] представляется одномерным массивом длиной nx*ny*nz, где элемент с индексами @{i, j, k@} находится как a[i+nx*j+nx*ny*k] (индексы отсчитываются от нуля). 43@end deftypecv 44@deftypecv {Variable} mglData @code{int} nx 45@deftypecvx {Variable} mglDataC @code{long} nx 46Размер массива по 1-ой размерности ('x' размерности). 47@end deftypecv 48@deftypecv {Variable} mglData @code{int} ny 49@deftypecvx {Variable} mglDataC @code{long} ny 50Размер массива по 2-ой размерности ('y' размерности). 51@end deftypecv 52@deftypecv {Variable} mglData @code{int} nz 53@deftypecvx {Variable} mglDataC @code{long} nz 54Размер массива по 3-ей размерности ('z' размерности). 55@end deftypecv 56@deftypecv {Variable} mglData @code{std::string} id 57@deftypecvx {Variable} mglDataC @code{std::string} id 58Имена колонки (или среза при nz>1) -- один символ на колонку. 59@end deftypecv 60@deftypecv {Variable} mglData @code{bool} link 61@deftypecvx {Variable} mglDataC @code{bool} link 62Флаг использования указателя на внешние данные, включает запрет на удаление массива данных. 63@end deftypecv 64 65@deftypecv {Variable} mglDataA @code{std::wstring} s 66Имя массива данных, использующееся при разборе MGL скриптов. 67@end deftypecv 68@deftypecv {Variable} mglDataA @code{bool} temp 69Флаг временной переменной, которая может быть удалена в любой момент. 70@end deftypecv 71@deftypecv {Variable} mglDataA @code{void (*)(void *)} func 72Указатель на callback функцию, которая будет вызвана при удлалении данных. 73@end deftypecv 74@deftypecv {Variable} mglDataA @code{void *} o 75Указатель для callback функции. 76@end deftypecv 77 78@deftypefn {Метод класса @code{mglData}} @code{mreal} GetVal (@code{long} i) 79@deftypefnx {Метод класса @code{mglDataC}} @code{mreal} GetVal (@code{long} i) 80@deftypefnx {Метод класса @code{mglData}} @code{void} SetVal (@code{mreal} val, @code{long} i) 81@deftypefnx {Метод класса @code{mglDataC}} @code{void} SetVal (@code{mreal} val, @code{long} i) 82Присваивает или возвращает значение используя "непрерывную" индексацию без проверки выхода за границы массива. Индекс @var{i} должен быть в диапазоне [0, nx*ny*nz-1]. 83@end deftypefn 84 85@deftypefn {Метод класса @code{mglDataA}} @code{long} GetNx () 86@deftypefnx {Метод класса @code{mglDataA}} @code{long} GetNy () 87@deftypefnx {Метод класса @code{mglDataA}} @code{long} GetNz () 88@deftypefnx {Функция С} @code{long} mgl_data_get_nx (@code{HCDT} dat) 89@deftypefnx {Функция С} @code{long} mgl_data_get_ny (@code{HCDT} dat) 90@deftypefnx {Функция С} @code{long} mgl_data_get_nz (@code{HCDT} dat) 91Возвращает размер данных в направлении x, y и z соответственно. 92@end deftypefn 93 94@deftypefn {Функция С} @code{mreal} mgl_data_get_value (@code{HCDT} dat, @code{int} i, @code{int} j, @code{int} k) 95@deftypefnx {Функция С} @code{dual} mgl_datac_get_value (@code{HCDT} dat, @code{int} i, @code{int} j, @code{int} k) 96@deftypefnx {Функция С} @code{mreal *} mgl_data_value (@code{HMDT} dat, @code{int} i, @code{int} j, @code{int} k) 97@deftypefnx {Функция С} @code{dual *} mgl_datac_value (@code{HADT} dat, @code{int} i, @code{int} j, @code{int} k) 98@deftypefnx {Функция С} @code{void} mgl_data_set_value (@code{HMDT} dat, @code{mreal} v, @code{int} i, @code{int} j, @code{int} k) 99@deftypefnx {Функция С} @code{void} mgl_datac_set_value (@code{HADT} dat, @code{dual} v, @code{int} i, @code{int} j, @code{int} k) 100Присваивает или возвращает значение ячейки данных с проверкой выхода за пределы массива. 101@end deftypefn 102@deftypefn {Функция С} @code{const mreal *} mgl_data_data (@code{HCDT} dat) 103Возвращает указатель на внутренний массив данных. 104@end deftypefn 105 106@deftypefn {Функция С} @code{void} mgl_data_set_func (@code{mglDataA *}dat, @code{void (*}func@code{)(void *)}, @code{void *}par) 107Задает указатель на callback функцию, которая будет вызвана при удлалении данных. 108@end deftypefn 109 110@deftypefn {Функция С} @code{void} mgl_data_set_name (@code{mglDataA *}dat, @code{const char *}name) 111@deftypefnx {Функция С} @code{void} mgl_data_set_name_w (@code{mglDataA *}dat, @code{const wchar_t *}name) 112Задает имя массива данных, использующееся при разборе MGL скриптов. 113@end deftypefn 114 115@end ifclear 116 117@c ------------------------------------------------------------------ 118@external{} 119@node Data constructor, Data resizing, Public variables, Data processing 120@section Создание и удаление данных 121@nav{} 122@cindex mglData 123 124@ifset UDAV 125There are many functions, which can create data for output (see @ref{Data filling}, @ref{File I/O}, @ref{Make another data}, @ref{Global functions}). Here I put most useful of them. 126@end ifset 127 128@anchor{new} 129@deftypefn {Команда MGL} {} new @sc{dat} [@code{nx=1} 'eq'] 130@deftypefnx {Команда MGL} {} new @sc{dat} @code{nx ny} ['eq'] 131@deftypefnx {Команда MGL} {} new @sc{dat} @code{nx ny nz} ['eq'] 132@ifclear UDAV 133@deftypefnx {Конструктор класса @code{mglData}} {} mglData (@code{int} mx=@code{1}, @code{int} my=@code{1}, @code{int} mz=@code{1}) 134@deftypefnx {Конструктор класса @code{mglDataC}} {} mglDataC (@code{int} mx=@code{1}, @code{int} my=@code{1}, @code{int} mz=@code{1}) 135@deftypefnx {Функция С} @code{HMDT} mgl_create_data () 136@deftypefnx {Функция С} @code{HMDT} mgl_create_data_size (@code{int} mx, @code{int} my, @code{int} mz) 137@end ifclear 138Выделяет память для массива данных и заполняет её нулями. Если указана формула @var{eq}, то данные заполняются также как при использовании @ref{fill}. 139@end deftypefn 140 141@anchor{copy} 142@deftypefn {Команда MGL} {} copy @sc{dat} dat2 ['eq'=''] 143@deftypefnx {Команда MGL} {} copy @sc{dat} @code{val} 144@ifclear UDAV 145@deftypefnx {Конструктор класса @code{mglData}} {} mglData (@code{const mglData &}dat2) 146@deftypefnx {Конструктор класса @code{mglData}} {} mglData (@code{const mglDataA *}dat2) 147@deftypefnx {Конструктор класса @code{mglData}} {} mglData (@code{int} size, @code{const mreal *}dat2) 148@deftypefnx {Конструктор класса @code{mglData}} {} mglData (@code{int} size, @code{int} cols, @code{const mreal *}dat2) 149@deftypefnx {Конструктор класса @code{mglData}} {} mglData (@code{int} size, @code{const double *}dat2) 150@deftypefnx {Конструктор класса @code{mglData}} {} mglData (@code{int} size, @code{int} cols, @code{const double *}dat2) 151@deftypefnx {Конструктор класса @code{mglData}} {} mglData (@code{const double *}dat2, @code{int} size) 152@deftypefnx {Конструктор класса @code{mglData}} {} mglData (@code{const double *}dat2, @code{int} size, @code{int} cols) 153@deftypefnx {Конструктор класса @code{mglDataC}} {} mglDataC (@code{const mglDataA &}dat2) 154@deftypefnx {Конструктор класса @code{mglDataC}} {} mglDataC (@code{const mglDataA *}dat2) 155@deftypefnx {Конструктор класса @code{mglDataC}} {} mglDataC (@code{int} size, @code{const float *}dat2) 156@deftypefnx {Конструктор класса @code{mglDataC}} {} mglDataC (@code{int} size, @code{int} cols, @code{const float *}dat2) 157@deftypefnx {Конструктор класса @code{mglDataC}} {} mglDataC (@code{int} size, @code{const double *}dat2) 158@deftypefnx {Конструктор класса @code{mglDataC}} {} mglDataC (@code{int} size, @code{int} cols, @code{const double *}dat2) 159@deftypefnx {Конструктор класса @code{mglDataC}} {} mglDataC (@code{int} size, @code{const dual *}dat2) 160@deftypefnx {Конструктор класса @code{mglDataC}} {} mglDataC (@code{int} size, @code{int} cols, @code{const dual *}dat2) 161@end ifclear 162Копирует данные из другого экземпляра данных. Если указана формула @var{eq}, то данные заполняются также как при использовании @ref{fill}. 163@end deftypefn 164 165@deftypefn {Команда MGL} {} copy @sc{redat} @sc{imdat} dat2 166Копирует действительную и мнимую часть данных из комплексного массива данных @var{dat2}. 167@end deftypefn 168 169@deftypefn {Команда MGL} {} copy @sc{dat} 'name' 170Копирует данные из другого экземпляра данных с именем @var{name}. При этом имя @var{name} может быть некорректным с точки зрения MGL (например, взятым из HDF5 файла). 171@end deftypefn 172 173 174 175@deftypefn {Команда MGL} {} read @sc{dat} 'fname' 176@ifclear UDAV 177@deftypefnx {Конструктор класса @code{mglData}} {} mglData (@code{const char *}fname) 178@deftypefnx {Конструктор класса @code{mglDataC}} {} mglDataC (@code{const char *}fname) 179@deftypefnx {Функция С} @code{HMDT} mgl_create_data_file (@code{const char *}fname) 180@deftypefnx {Функция С} @code{HADT} mgl_create_datac_file (@code{const char *}fname) 181@end ifclear 182Читает данные из текстового файла с автоматическим определением размеров массива. 183@end deftypefn 184 185@deftypefn {Команда MGL} {} delete dat 186@deftypefnx {Команда MGL} {} delete 'name' 187@ifclear UDAV 188@deftypefnx {Destructor on @code{mglData}} {} ~mglData () 189@deftypefnx {Функция С} @code{void} mgl_delete_data (@code{HMDT} dat) 190@deftypefnx {Destructor on @code{mglDataC}} {} ~mglDataC () 191@deftypefnx {Функция С} @code{void} mgl_delete_datac (@code{HADT} dat) 192@end ifclear 193Удаляет массив данных из памяти. 194@end deftypefn 195 196 197@c ------------------------------------------------------------------ 198@external{} 199@node Data resizing, Data filling, Data constructor, Data processing 200@section Изменение размеров данных 201@nav{} 202@cindex Create 203@cindex Rearrange 204@cindex Extend 205@cindex Transpose 206@cindex Squeeze 207@cindex Crop 208@cindex Insert 209@cindex Delete 210@cindex Sort 211@cindex Clean 212@cindex Join 213 214 215@deftypefn {Команда MGL} {} new @sc{dat} [@code{nx=1 ny=1 nz=1}] 216@ifclear UDAV 217@deftypefnx {Метод класса @code{mglData}} @code{void} Create (@code{int} mx, @code{int} my=@code{1}, @code{int} mz=@code{1}) 218@deftypefnx {Метод класса @code{mglDataC}} @code{void} Create (@code{int} mx, @code{int} my=@code{1}, @code{int} mz=@code{1}) 219@deftypefnx {Функция С} @code{void} mgl_data_create (@code{HMDT} dat, @code{int} mx, @code{int} my, @code{int} mz) 220@deftypefnx {Функция С} @code{void} mgl_datac_create (@code{HADT} dat, @code{int} mx, @code{int} my, @code{int} mz) 221@end ifclear 222Создает/пересоздает массив данных указанного размера и заполняет его нулями. Ничего не делает при @var{mx}, @var{my}, @var{mz} отрицательных или равных нулю. 223@end deftypefn 224 225@anchor{rearrange} 226@deftypefn {Команда MGL} {} rearrange dat @code{mx [my=0 mz=0]} 227@ifclear UDAV 228@deftypefnx {Метод класса @code{mglData}} @code{void} Rearrange (@code{int} mx, @code{int} my=@code{0}, @code{int} mz=@code{0}) 229@deftypefnx {Метод класса @code{mglDataC}} @code{void} Rearrange (@code{int} mx, @code{int} my=@code{0}, @code{int} mz=@code{0}) 230@deftypefnx {Функция С} @code{void} mgl_data_rearrange (@code{HMDT} dat, @code{int} mx, @code{int} my, @code{int} mz) 231@deftypefnx {Функция С} @code{void} mgl_datac_rearrange (@code{HADT} dat, @code{int} mx, @code{int} my, @code{int} mz) 232@end ifclear 233Изменяет размерность данных без изменения самого массива данных, так что результирующий массив @var{mx}*@var{my}*@var{mz} < nx*ny*nz. Если один из параметров @var{my} или @var{mz} ноль, то он будет выбран оптимальным образом. Например, если @var{my}=0, то будет @var{my}=nx*ny*nz/@var{mx} и @var{mz}=1. 234@end deftypefn 235 236@anchor{transpose} 237@deftypefn {Команда MGL} {} transpose dat ['dim'='yxz'] 238@ifclear UDAV 239@deftypefnx {Метод класса @code{mglData}} @code{void} Transpose (@code{const char *}dim=@code{"yx"}) 240@deftypefnx {Метод класса @code{mglDataC}} @code{void} Transpose (@code{const char *}dim=@code{"yx"}) 241@deftypefnx {Функция С} @code{void} mgl_data_transpose (@code{const char *}dim) 242@deftypefnx {Функция С} @code{void} mgl_datac_transpose (@code{HADT} dat, @code{const char *}dim) 243@end ifclear 244Транспонирует (меняет порядок размерностей) массив данных. Новый порядок размерностей задается строкой @var{dim}. Функция может быть полезна для транспонирования одномерных (или квазиодномерных) массивов после чтения их из файла. 245@end deftypefn 246 247@anchor{extend} 248@deftypefn {Команда MGL} {} extend dat @code{n1 [n2=0]} 249@ifclear UDAV 250@deftypefnx {Метод класса @code{mglData}} @code{void} Extend (@code{int} n1, @code{int} n2=@code{0}) 251@deftypefnx {Метод класса @code{mglDataC}} @code{void} Extend (@code{int} n1, @code{int} n2=@code{0}) 252@deftypefnx {Функция С} @code{void} mgl_data_extend (@code{HMDT} dat, @code{int} n1, @code{int} n2) 253@deftypefnx {Функция С} @code{void} mgl_datac_extend (@code{HADT} dat, @code{int} n1, @code{int} n2) 254@end ifclear 255Увеличивает размер данных путем вставки (|@var{n1}|+1) новых срезов после (для @var{n1}>0) или перед (для @var{n1}<0) существующими данными. Можно добавить сразу 2 размерности для 1d массива, используя второй параметр @var{n2}. Данные в новые срезы будут скопированы из существующих. Например, для @var{n1}>0 новый массив будет 256@iftex 257@math{a_{ij}^{new} = a_i^{old}} where j=0...@var{n1}. Соответственно, для @var{n1}<0 новый массив будет @math{a_{ij}^{new} = a_j^{old}}, где i=0...|@var{n1}|. 258@end iftex 259@ifnottex 260a_ij^new = a_i^old where j=0...@var{n1}. Соответственно, для @var{n1}<0 новый массив будет a_ij^new = a_j^old, где i=0...|@var{n1}|. 261@end ifnottex 262@end deftypefn 263 264@anchor{squeeze} 265@deftypefn {Команда MGL} {} squeeze dat @code{rx [ry=1 rz=1 sm=off]} 266@ifclear UDAV 267@deftypefnx {Метод класса @code{mglData}} @code{void} Squeeze (@code{int} rx, @code{int} ry=@code{1}, @code{int} rz=@code{1}, @code{bool} smooth=@code{false}) 268@deftypefnx {Метод класса @code{mglDataC}} @code{void} Squeeze (@code{int} rx, @code{int} ry=@code{1}, @code{int} rz=@code{1}, @code{bool} smooth=@code{false}) 269@deftypefnx {Функция С} @code{void} mgl_data_squeeze (@code{HMDT} dat, @code{int} rx, @code{int} ry, @code{int} rz, @code{int} smooth) 270@deftypefnx {Функция С} @code{void} mgl_datac_squeeze (@code{HADT} dat, @code{int} rx, @code{int} ry, @code{int} rz, @code{int} smooth) 271@end ifclear 272Уменьшает размер данных путём удаления элементов с индексами не кратными @var{rx}, @var{ry}, @var{rz} соответственно. Параметр @var{smooth} задает использовать сглаживания 273@iftex 274(т.е. @math{a_{out}[i]=\sum_{j=i,i+r}a[j]/r}) или нет (т.е. @math{a_{out}[i]=a[j*r]}). 275@end iftex 276@ifnottex 277(т.е. out[i]=\sum_@{j=i,i+r@} a[j]/r) или нет (т.е. out[i]=a[j*r]). 278@end ifnottex 279@end deftypefn 280 281@anchor{crop} 282@deftypefn {Команда MGL} {} crop dat @code{n1 n2} 'dir' 283@ifclear UDAV 284@deftypefnx {Метод класса @code{mglData}} @code{void} Crop (@code{int} n1, @code{int} n2, @code{char} dir=@code{'x'}) 285@deftypefnx {Метод класса @code{mglDataC}} @code{void} Crop (@code{int} n1, @code{int} n2, @code{char} dir=@code{'x'}) 286@deftypefnx {Функция С} @code{void} mgl_data_crop (@code{HMDT} dat, @code{int} n1, @code{int} n2, @code{char} dir) 287@deftypefnx {Функция С} @code{void} mgl_datac_crop (@code{HADT} dat, @code{int} n1, @code{int} n2, @code{char} dir) 288@end ifclear 289Обрезает границы данных при @var{i}<@var{n1} и @var{i}>@var{n2} (при @var{n2}>0) или @var{i}>@code{n[xyz]}-@var{n2} (при @var{n2}<=0) вдоль направления @var{dir}. 290@end deftypefn 291 292@deftypefn {Команда MGL} {} crop dat 'how' 293@ifclear UDAV 294@deftypefnx {Метод класса @code{mglData}} @code{void} Crop (@code{const char *}how=@code{"235x"}) 295@deftypefnx {Метод класса @code{mglDataC}} @code{void} Crop (@code{const char *}how=@code{"235x"}) 296@deftypefnx {Функция Сn} @code{void} mgl_data_crop_opt (@code{HMDT} dat, @code{const char *}how) 297@deftypefnx {Функция Сn} @code{void} mgl_datac_crop_opt (@code{HADT} dat, @code{const char *}how) 298@end ifclear 299Обрезает дальний край данных, чтобы сделать их более оптимальным для быстрого преобразования Фурье. Размер массива будет равен наиболее близким к исходному из 2^n*3^m*5^l. Строка @var{how} может содержать: @samp{x}, @samp{y}, @samp{z} для направлений, и @samp{2}, @samp{3}, @samp{5} для использования соответствующего основания. 300@end deftypefn 301 302@anchor{insert} 303@deftypefn {Команда MGL} {} insert dat 'dir' @code{[pos=off num=0]} 304@ifclear UDAV 305@deftypefnx {Метод класса @code{mglData}} @code{void} Insert (@code{char} dir, @code{int} pos=@code{0}, @code{int} num=@code{1}) 306@deftypefnx {Метод класса @code{mglDataC}} @code{void} Insert (@code{char} dir, @code{int} pos=@code{0}, @code{int} num=@code{1}) 307@deftypefnx {Функция С} @code{void} mgl_data_insert (@code{HMDT} dat, @code{char} dir, @code{int} pos, @code{char} num) 308@deftypefnx {Функция С} @code{void} mgl_datac_insert (@code{HADT} dat, @code{char} dir, @code{int} pos, @code{char} num) 309@end ifclear 310Вставляет @var{num} срезов вдоль направления @var{dir} с позиции @var{pos} и заполняет их нулями. 311@end deftypefn 312 313@anchor{delete} 314@deftypefn {Команда MGL} {} delete dat 'dir' @code{[pos=off num=0]} 315@ifclear UDAV 316@deftypefnx {Метод класса @code{mglData}} @code{void} Delete (@code{char} dir, @code{int} pos=@code{0}, @code{int} num=@code{1}) 317@deftypefnx {Метод класса @code{mglDataC}} @code{void} Delete (@code{char} dir, @code{int} pos=@code{0}, @code{int} num=@code{1}) 318@deftypefnx {Функция С} @code{void} mgl_data_delete (@code{HMDT} dat, @code{char} dir, @code{int} pos, @code{char} num) 319@deftypefnx {Функция С} @code{void} mgl_datac_delete (@code{HADT} dat, @code{char} dir, @code{int} pos, @code{char} num) 320@end ifclear 321Удаляет @var{num} срезов вдоль направления @var{dir} с позиции @var{pos}. 322@end deftypefn 323 324@deftypefn {Команда MGL} {} delete dat 325@deftypefnx {Команда MGL} {} delete 'name' 326Удаляет массив данных из памяти. 327@end deftypefn 328 329@anchor{sort} 330@deftypefn {Команда MGL} {} sort dat @code{idx [idy=-1]} 331@ifclear UDAV 332@deftypefnx {Метод класса @code{mglData}} @code{void} Sort (@code{lond} idx, @code{long} idy=@code{-1}) 333@deftypefnx {Функция С} @code{void} mgl_data_sort (@code{HMDT} dat, @code{lond} idx, @code{long} idy) 334@end ifclear 335Сортирует строки (или срезы в 3D случае) по значениям в указанной колонке @var{idx} (или ячейках @{@var{idx},@var{idy}@} для 3D случая). Не используйте в многопоточных функциях! 336@end deftypefn 337 338@anchor{clean} 339@deftypefn {Команда MGL} {} clean dat @code{idx} 340@ifclear UDAV 341@deftypefnx {Метод класса @code{mglData}} @code{void} Clean (@code{lond} idx) 342@deftypefnx {Функция С} @code{void} mgl_data_clean (@code{HMDT} dat, @code{lond} idx) 343@end ifclear 344Удаляет строки в которых значения для заданной колонки @var{idx} совпадают со значениями в следующей строке. 345@end deftypefn 346 347 348@anchor{join} 349@deftypefn {Команда MGL} {} join dat vdat [v2dat ...] 350@ifclear UDAV 351@deftypefnx {Метод класса @code{mglData}} @code{void} Join (@code{const mglDataA &}vdat) 352@deftypefnx {Метод класса @code{mglDataC}} @code{void} Join (@code{const mglDataA &}vdat) 353@deftypefnx {Функция С} @code{void} mgl_data_join (@code{HMDT} dat, @code{HCDT} vdat) 354@deftypefnx {Функция С} @code{void} mgl_datac_join (@code{HADT} dat, @code{HCDT} vdat) 355@end ifclear 356Объединяет данные из массива @var{vdat} с данными массива @var{dat}. При этом, функция увеличивает размер массива @var{dat}: в z-направлении для массивов с одинаковыми размерами по x и y; в y-направлении для массивов с одинаковыми размерами по x; в x-направлении в остальных случаях. 357@end deftypefn 358 359@c ------------------------------------------------------------------ 360@external{} 361@node Data filling, File I/O, Data resizing, Data processing 362@section Заполнение данных 363@nav{} 364@cindex Fill 365@cindex Modify 366@cindex Set 367@cindex List 368@cindex Var 369@cindex Refill 370 371@anchor{list} 372@deftypefn {Команда MGL} {} list @sc{dat} @code{v1 ...} 373Создает новый массив данных @var{dat} и заполняет его числовыми значениями аргументов @code{v1 ...}. Команда может создавать одно- и двухмерные массивы с произвольными значениями. Для создания 2d массива следует использовать разделитель @samp{|}, который означает начало новой строки данных. Размер массива данных будет [maximal of row sizes * number of rows]. Например, команда @code{list 1 | 2 3} создаст массив [1 0; 2 3]. Замечу, что максимальное число аргументов равно 1000. 374@end deftypefn 375@deftypefn {Команда MGL} {} list @sc{dat} d1 ... 376Создает новый массив данных @var{dat} и заполняет его значениями из массивов @var{d1 ...}. Команда может создавать двух- и трёхмерные (если аргументы -- двумерные массивы) массивы. Меньшая размерность всех массивов в аргументах должна совпадать. В противном случае аргумент (массив) будет пропущен. 377@end deftypefn 378 379@ifclear UDAV 380@deftypefn {Метод класса @code{mglData}} @code{void} Set (@code{const mreal *}A, @code{int} NX, @code{int} NY=@code{1}, @code{int} NZ=@code{1}) 381@deftypefnx {Метод класса @code{mglData}} @code{void} Set (@code{const double *}A, @code{int} NX, @code{int} NY=@code{1}, @code{int} NZ=@code{1}) 382@deftypefnx {Функция С} @code{void} mgl_data_set_mreal (@code{HMDT} dat, @code{const mreal *}A, @code{int} NX, @code{int} NY, @code{int} NZ) 383@deftypefnx {Функция С} @code{void} mgl_data_set_double (@code{HMDT} dat, @code{const double *}A, @code{int} NX, @code{int} NY, @code{int} NZ) 384@deftypefnx {Метод класса @code{mglDataC}} @code{void} Set (@code{const float *}A, @code{int} NX, @code{int} NY=@code{1}, @code{int} NZ=@code{1}) 385@deftypefnx {Метод класса @code{mglDataC}} @code{void} Set (@code{const double *}A, @code{int} NX, @code{int} NY=@code{1}, @code{int} NZ=@code{1}) 386@deftypefnx {Метод класса @code{mglDataC}} @code{void} Set (@code{const dual *}A, @code{int} NX, @code{int} NY=@code{1}, @code{int} NZ=@code{1}) 387@deftypefnx {Функция С} @code{void} mgl_datac_set_float (@code{HADT} dat, @code{const mreal *}A, @code{int} NX, @code{int} NY, @code{int} NZ) 388@deftypefnx {Функция С} @code{void} mgl_datac_set_double (@code{HADT} dat, @code{const double *}A, @code{int} NX, @code{int} NY, @code{int} NZ) 389@deftypefnx {Функция С} @code{void} mgl_datac_set_complex (@code{HADT} dat, @code{const dual *}A, @code{int} NX, @code{int} NY, @code{int} NZ) 390Выделяет память и копирует данные из массивов типа @code{mreal*} или @code{double*}, т.е. из массивов определённых как @code{mreal a[NX*NY*NZ];}. 391@end deftypefn 392 393@deftypefn {Метод класса @code{mglData}} @code{void} Set (@code{const mreal **}A, @code{int} N1, @code{int} N2) 394@deftypefnx {Метод класса @code{mglData}} @code{void} Set (@code{const double **}A, @code{int} N1, @code{int} N2) 395@deftypefnx {Функция С} @code{void} mgl_data_set_mreal2 (@code{HMDT} dat, @code{const mreal **}A, @code{int} N1, @code{int} N2) 396@deftypefnx {Функция С} @code{void} mgl_data_set_double2 (@code{HMDT} dat, @code{const double **}A, @code{int} N1, @code{int} N2) 397Выделяет память и копирует данные из массивов типа @code{mreal**} или @code{double**} с размерностями @var{N1}, @var{N2}, т.е. из массивов определённых как @code{mreal a[N1][N2];}. 398@end deftypefn 399 400@deftypefn {Метод класса @code{mglData}} @code{void} Set (@code{const mreal ***}A, @code{int} N1, @code{int} N2) 401@deftypefnx {Метод класса @code{mglData}} @code{void} Set (@code{const double ***}A, @code{int} N1, @code{int} N2) 402@deftypefnx {Функция С} @code{void} mgl_data_set_mreal3 (@code{HMDT} dat, @code{const mreal ***}A, @code{int} N1, @code{int} N2) 403@deftypefnx {Функция С} @code{void} mgl_data_set_double3 (@code{HMDT} dat, @code{const double ***}A, @code{int} N1, @code{int} N2) 404Выделяет память и копирует данные из массивов типа @code{mreal***} или @code{double***} с размерностями @var{N1}, @var{N2}, @var{N3}, т.е. из массивов определённых как @code{mreal a[N1][N2][N3];}. 405@end deftypefn 406 407@deftypefn {Метод класса @code{mglData}} @code{void} Set (@code{gsl_vector *}v) 408@deftypefnx {Метод класса @code{mglDataC}} @code{void} Set (@code{gsl_vector *}v) 409@deftypefnx {Функция С} @code{void} mgl_data_set_vector (@code{HMDT} dat, @code{gsl_vector *}v) 410@deftypefnx {Функция С} @code{void} mgl_datac_set_vector (@code{HADT} dat, @code{gsl_vector *}v) 411Выделяет память и копирует данные из структуры типа @code{gsl_vector *}. 412@end deftypefn 413@deftypefn {Метод класса @code{mglData}} @code{void} Set (@code{gsl_matrix *}m) 414@deftypefnx {Метод класса @code{mglDataC}} @code{void} Set (@code{gsl_matrix *}m) 415@deftypefnx {Функция С} @code{void} mgl_data_set_matrix (@code{HMDT} dat, @code{gsl_matrix *}m) 416@deftypefnx {Функция С} @code{void} mgl_datac_set_matrix (@code{HADT} dat, @code{gsl_matrix *}m) 417Выделяет память и копирует данные из структуры типа @code{gsl_matrix *}. 418@end deftypefn 419@deftypefn {Метод класса @code{mglData}} @code{void} Set (@code{const mglDataA &}from) 420@deftypefnx {Метод класса @code{mglData}} @code{void} Set (@code{HCDT} from) 421@deftypefnx {Функция С} @code{void} mgl_data_set (@code{HMDT} dat, @code{HCDT} from) 422@deftypefnx {Метод класса @code{mglDataC}} @code{void} Set (@code{const mglDataA &}from) 423@deftypefnx {Метод класса @code{mglDataC}} @code{void} Set (@code{HCDT} from) 424@deftypefnx {Функция С} @code{void} mgl_datac_set (@code{HADT} dat, @code{HCDT} from) 425Выделяет память и копирует данные из другого экземпляра данных @var{from}. 426@end deftypefn 427 428@deftypefn {Метод класса @code{mglDataC}} @code{void} Set (@code{const mglDataA &}re, @code{const mglDataA &}im) 429@deftypefnx {Метод класса @code{mglDataC}} @code{void} Set (@code{HCDT} re, @code{HCDT} im) 430@deftypefnx {Метод класса @code{mglDataC}} @code{void} SetAmpl (@code{HCDT} ampl, @code{const mglDataA &}phase) 431@deftypefnx {Функция С} @code{void} mgl_datac_set_ri (@code{HADT} dat, @code{HCDT} re, @code{HCDT} im) 432@deftypefnx {Функция С} @code{void} mgl_datac_set_ap (@code{HADT} dat, @code{HCDT} ampl, @code{HCDT} phase) 433Выделяет память и копирует данные из экземпляра данных для действительной @var{re} и мнимой @var{im} частей комплексного массива данных. 434@end deftypefn 435 436@deftypefn {Метод класса @code{mglData}} @code{void} Set (@code{const std::vector<int> &}d) 437@deftypefnx {Метод класса @code{mglDataC}} @code{void} Set (@code{const std::vector<int> &}d) 438@deftypefnx {Метод класса @code{mglData}} @code{void} Set (@code{const std::vector<float> &}d) 439@deftypefnx {Метод класса @code{mglDataC}} @code{void} Set (@code{const std::vector<float> &}d) 440@deftypefnx {Метод класса @code{mglData}} @code{void} Set (@code{const std::vector<double> &}d) 441@deftypefnx {Метод класса @code{mglDataC}} @code{void} Set (@code{const std::vector<double> &}d) 442@deftypefnx {Метод класса @code{mglDataC}} @code{void} Set (@code{const std::vector<dual> &}d) 443Выделяет память и копирует данные из массива типа @code{std::vector<T>}. 444@end deftypefn 445 446@deftypefn {Метод класса @code{mglData}} @code{void} Set (@code{const char *}str, @code{int} NX, @code{int} NY=@code{1}, @code{int} NZ=@code{1}) 447@deftypefnx {Функция С} @code{void} mgl_data_set_values (@code{const char *}str, @code{int} NX, @code{int} NY, @code{int} NZ) 448@deftypefnx {Метод класса @code{mglDataC}} @code{void} Set (@code{const char *}str, @code{int} NX, @code{int} NY=@code{1}, @code{int} NZ=@code{1}) 449@deftypefnx {Функция С} @code{void} mgl_datac_set_values (@code{const char *}str, @code{int} NX, @code{int} NY, @code{int} NZ) 450Выделяет память и сканирует массив данных из строки. 451@end deftypefn 452 453 454@deftypefn {Метод класса @code{mglData}} @code{void} SetList (@code{long} n, ...) 455Allocate memory and set data from variable argument list of @emph{double} values. Note, you need to specify decimal point @samp{.} for integer values! For example, the code @code{SetList(2,0.,1.);} is correct, but the code @code{SetList(2,0,1);} is incorrect. 456@end deftypefn 457 458 459 460@deftypefn {Метод класса @code{mglData}} @code{void} Set (@code{const arma::vec &}d) 461@deftypefnx {Метод класса @code{mglData}} @code{void} Set (@code{const arma::mat &}d) 462@deftypefnx {Метод класса @code{mglData}} @code{void} Set (@code{const arma::cube &}d) 463@deftypefnx {Метод класса @code{mglDataC}} @code{void} Set (@code{const arma::vec &}d) 464@deftypefnx {Метод класса @code{mglDataC}} @code{void} Set (@code{const arma::cx_vec &}d) 465@deftypefnx {Метод класса @code{mglDataC}} @code{void} Set (@code{const arma::mat &}d) 466@deftypefnx {Метод класса @code{mglDataC}} @code{void} Set (@code{const arma::cx_mat &}d) 467@deftypefnx {Метод класса @code{mglDataC}} @code{void} Set (@code{const arma::cube &}d) 468@deftypefnx {Метод класса @code{mglDataC}} @code{void} Set (@code{const arma::cx_cube &}d) 469Выделяет память и копирует данные из Armadillo структур. 470@end deftypefn 471 472@deftypefn {Метод класса @code{mglData}} @code{arma::mat} arma_mat (@code{long} k=0) 473@deftypefnx {Метод класса @code{mglData}} @code{arma::cube} arma_cube () 474@deftypefnx {Метод класса @code{mglData}} @code{arma::cx_mat} arma_mat (@code{long} k=0) 475@deftypefnx {Метод класса @code{mglData}} @code{arma::cx_cube} arma_cube () 476Возвращает данные в формате структур Armadillo. 477@end deftypefn 478 479 480 481@deftypefn {Метод класса @code{mglData}} @code{void} Link (@code{mglData &}from) 482@deftypefnx {Метод класса @code{mglData}} @code{void} Link (@code{mreal *}A, @code{int} NX, @code{int} NY=@code{1}, @code{int} NZ=@code{1}) 483@deftypefnx {Функция С} @code{void} mgl_data_link (@code{HMDT} dat, @code{const mreal *}A, @code{int} NX, @code{int} NY, @code{int} NZ) 484@deftypefnx {Метод класса @code{mglDataC}} @code{void} Link (@code{mglDataC &}from) 485@deftypefnx {Метод класса @code{mglDataC}} @code{void} Link (@code{dual *}A, @code{int} NX, @code{int} NY=@code{1}, @code{int} NZ=@code{1}) 486@deftypefnx {Функция С} @code{void} mgl_datac_link (@code{HADT} dat, @code{const mreal *}A, @code{int} NX, @code{int} NY, @code{int} NZ) 487Устанавливает флаг использования внешнего массива данных, которые не будут удалены. Флаг может быть возвращён в исходное состояние и создан новый внутренний массив если использовались функции изменяющие размер данных. 488@end deftypefn 489@end ifclear 490 491@anchor{var} 492@deftypefn {Команда MGL} {} var @sc{dat} @code{num v1 [v2=nan]} 493Создает новый одномерный массив данных @var{dat} размером @var{num}, и заполняет его равномерно в диапазоне [@var{v1}, @var{v2}]. Если @var{v2}=@code{nan}, то используется @var{v2=v1}. 494@end deftypefn 495 496@anchor{fill} 497@deftypefn {Команда MGL} {} fill dat v1 v2 ['dir'='x'] 498@ifclear UDAV 499@deftypefnx {Метод класса @code{mglData}} @code{void} Fill (@code{mreal} v1, @code{mreal} v2, @code{char} dir=@code{'x'}) 500@deftypefnx {Метод класса @code{mglDataC}} @code{void} Fill (@code{dual} v1, @code{dual} v2, @code{char} dir=@code{'x'}) 501@deftypefnx {Функция С} @code{void} mgl_data_fill (@code{HMDT} dat, @code{mreal} v1, @code{mreal} v2, @code{char} dir) 502@deftypefnx {Функция С} @code{void} mgl_datac_fill (@code{HADT} dat, @code{dual} v1, @code{dual} v2, @code{char} dir) 503@end ifclear 504Заполняет значениями равно распределёнными в диапазоне [@var{x1}, @var{x2}] в направлении @var{dir}=@{@samp{x},@samp{y},@samp{z}@}. 505@end deftypefn 506 507@deftypefn {Команда MGL} {} fill dat 'eq'[vdat wdat] 508@ifclear UDAV 509@deftypefnx {Метод класса @code{mglData}} @code{void} Fill (@code{HMGL} gr, @code{const char *}eq, @code{const char *}opt=@code{""}) 510@deftypefnx {Метод класса @code{mglData}} @code{void} Fill (@code{HMGL} gr, @code{const char *}eq, @code{const mglDataA &}vdat, @code{const char *}opt=@code{""}) 511@deftypefnx {Метод класса @code{mglData}} @code{void} Fill (@code{HMGL} gr, @code{const char *}eq, @code{const mglDataA &}vdat, @code{const mglDataA &}wdat, @code{const char *}opt=@code{""}) 512@deftypefnx {Метод класса @code{mglDataC}} @code{void} Fill (@code{HMGL} gr, @code{const char *}eq, @code{const char *}opt=@code{""}) 513@deftypefnx {Метод класса @code{mglDataC}} @code{void} Fill (@code{HMGL} gr, @code{const char *}eq, @code{const mglDataA &}vdat, @code{const char *}opt=@code{""}) 514@deftypefnx {Метод класса @code{mglDataC}} @code{void} Fill (@code{HMGL} gr, @code{const char *}eq, @code{const mglDataA &}vdat, @code{const mglDataA &}wdat, @code{const char *}opt=@code{""}) 515@deftypefnx {Функция С} @code{void} mgl_data_fill_eq (@code{HMGL} gr, @code{HMDT} dat, @code{const char *}eq, @code{HCDT} vdat, @code{HCDT} wdat, @code{const char *}opt) 516@deftypefnx {Функция С} @code{void} mgl_datac_fill_eq (@code{HMGL} gr, @code{HADT} dat, @code{const char *}eq, @code{HCDT} vdat, @code{HCDT} wdat, @code{const char *}opt) 517@end ifclear 518Заполняет значениями вычисленными по формуле @var{eq}. Формула представляет собой произвольное выражение, зависящее от переменных @samp{x}, @samp{y}, @samp{z}, @samp{u}, @samp{v}, @samp{w}. Координаты @samp{x}, @samp{y}, @samp{z} полагаются меняющимися в диапазоне @var{Min} x @var{Max} (в отличие от функции @code{Modify}). Переменные @samp{i}, @samp{j}, @samp{k} равны значениям соответствующего индекса. При этом, используются нулевые значения для переменных, отвечающих отсутствующим размерностям. Переменная @samp{u} -- значения исходного массива, переменные @samp{v}, @samp{w} -- значения массивов @var{vdat}, @var{wdat}. Последние могут быть @code{NULL}, т.е. опущены. 519@end deftypefn 520 521@anchor{modify} 522@deftypefn {Команда MGL} {} modify dat 'eq' [@code{dim=0}] 523@deftypefnx {Команда MGL} {} modify dat 'eq' vdat [wdat] 524@ifclear UDAV 525@deftypefnx {Метод класса @code{mglData}} @code{void} Modify (@code{const char *}eq, @code{int} dim=@code{0}) 526@deftypefnx {Метод класса @code{mglData}} @code{void} Modify (@code{const char *}eq, @code{const mglDataA &}v) 527@deftypefnx {Метод класса @code{mglData}} @code{void} Modify (@code{const char *}eq, @code{const mglDataA &}v, @code{const mglDataA &}w) 528@deftypefnx {Метод класса @code{mglDataC}} @code{void} Modify (@code{const char *}eq, @code{int} dim=@code{0}) 529@deftypefnx {Метод класса @code{mglDataC}} @code{void} Modify (@code{const char *}eq, @code{const mglDataA &}v) 530@deftypefnx {Метод класса @code{mglDataC}} @code{void} Modify (@code{const char *}eq, @code{const mglDataA &}v, @code{const mglDataA &}w) 531@deftypefnx {Функция С} @code{void} mgl_data_modify (@code{HMDT} dat, @code{const char *}eq, @code{int} dim) 532@deftypefnx {Функция С} @code{void} mgl_data_modify_vw (@code{HMDT} dat, @code{const char *}eq, @code{HCDT} v, @code{HCDT} w) 533@deftypefnx {Функция С} @code{void} mgl_datac_modify (@code{HADT} dat, @code{const char *}eq, @code{int} dim) 534@deftypefnx {Функция С} @code{void} mgl_datac_modify_vw (@code{HADT} dat, @code{const char *}eq, @code{HCDT} v, @code{HCDT} w) 535@end ifclear 536Аналогично предыдущему с координатами @samp{x}, @samp{y}, @samp{z}, меняющимися в диапазоне [0,1]. Переменные @samp{i}, @samp{j}, @samp{k} равны значениям соответствующего индекса. При этом, используются нулевые значения для переменных, отвечающих отсутствующим размерностям. Если указан @var{dim}>0, то изменяются только слои >=@var{dim}. 537@end deftypefn 538 539@anchor{fillsample} 540@deftypefn {Команда MGL} {} fillsample dat 'how' 541@ifclear UDAV 542@deftypefnx {Метод класса @code{mglData}} @code{void} FillSample (@code{const char *}how) 543@deftypefnx {Функция С} @code{void} mgl_data_fill_sample (@code{HMDT} a, @code{const char *}how) 544@end ifclear 545Заполняет массив данных 'x' или 'k' значениями для преобразований Ханкеля ('h') или Фурье ('f'). 546@end deftypefn 547 548 549@anchor{datagrid} 550@deftypefn {Команда MGL} {} datagrid dat xdat ydat zdat 551@ifclear UDAV 552@deftypefnx {Метод класса @code{mglData}} @code{mglData} Grid (@code{HMGL} gr, @code{const mglDataA &}x, @code{const mglDataA &}y, @code{const mglDataA &}z, @code{const char *}opt=@code{""}) 553@deftypefnx {Метод класса @code{mglData}} @code{mglData} Grid (@code{const mglDataA &}x, @code{const mglDataA &}y, @code{const mglDataA &}z, @code{mglPoint} p1, @code{mglPoint} p2) 554@deftypefnx {Функция С} @code{void} mgl_data_grid (@code{HMGL} gr, @code{HMDT} u, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{const char *}opt) 555@deftypefnx {Функция С} @code{void} mgl_data_grid_xy (@code{HMDT} u, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{mreal} x1, @code{mreal} x2, @code{mreal} y1, @code{mreal} y2) 556@end ifclear 557Заполняет значения массива результатом линейной интерполяции (считая координаты равнораспределенными в диапазоне осей координат или в диапазоне [x1,x2]*[y1,y2]) по триангулированной поверхности, найденной по произвольно расположенным точкам @samp{x}, @samp{y}, @samp{z}. NAN значение используется для точек сетки вне триангулированной поверхности. @sref{Making regular data} 558@end deftypefn 559 560 561@anchor{put} 562@deftypefn {Команда MGL} {} put dat @code{val [i=all j=all k=all]} 563@ifclear UDAV 564@deftypefnx {Метод класса @code{mglData}} @code{void} Put (@code{mreal} val, @code{int} i=@code{-1}, @code{int} j=@code{-1}, @code{int} k=@code{-1}) 565@deftypefnx {Метод класса @code{mglDataC}} @code{void} Put (@code{dual} val, @code{int} i=@code{-1}, @code{int} j=@code{-1}, @code{int} k=@code{-1}) 566@deftypefnx {Функция С} @code{void} mgl_data_put_val (@code{HMDT} a, @code{mreal} val, @code{int} i, @code{int} j, @code{int} k) 567@deftypefnx {Функция С} @code{void} mgl_datac_put_val (@code{HADT} a, @code{dual} val, @code{int} i, @code{int} j, @code{int} k) 568@end ifclear 569Присваивает значения (под-)массива @var{dat}[@var{i}, @var{j}, @var{k}] = @var{val}. Индексы @var{i}, @var{j}, @var{k} равные @samp{-1} задают значения @var{val} для всего диапазона соответствующего направления(ий). Например, @code{Put(val,-1,0,-1);} задает a[i,0,j]=@var{val} для i=0...(nx-1), j=0...(nz-1). 570@end deftypefn 571 572@deftypefn {Команда MGL} {} put dat vdat [@code{i=all j=all k=all}] 573@ifclear UDAV 574@deftypefnx {Метод класса @code{mglData}} @code{void} Put (@code{const mglDataA &}v, @code{int} i=@code{-1}, @code{int} j=@code{-1}, @code{int} k=@code{-1}) 575@deftypefnx {Метод класса @code{mglDataC}} @code{void} Put (@code{const mglDataA &}v, @code{int} i=@code{-1}, @code{int} j=@code{-1}, @code{int} k=@code{-1}) 576@deftypefnx {Функция С} @code{void} mgl_data_put_dat (@code{HMDT} a, @code{HCDT} v, @code{int} i, @code{int} j, @code{int} k) 577@deftypefnx {Функция С} @code{void} mgl_datac_put_dat (@code{HADT} a, @code{HCDT} v, @code{int} i, @code{int} j, @code{int} k) 578@end ifclear 579Копирует значения из массива @var{v} в диапазон значений данного массива. Индексы @var{i}, @var{j}, @var{k} равные @samp{-1} задают диапазон изменения значений в соответствующих направление(ях). Младшие размерности массива @var{v} должны быть больше выбранного диапазона массива. Например, @code{Put(v,-1,0,-1);} присвоит a[i,0,j]=@var{v}.ny>nz ? @var{v}.a[i,j] : @var{v}.a[i], где i=0...(nx-1), j=0...(nz-1) и условие v.nx>=nx выполнено. 580@end deftypefn 581 582@anchor{refill} 583@deftypefn {Команда MGL} {} refill dat xdat vdat [sl=-1] 584@deftypefnx {Команда MGL} {} refill dat xdat ydat vdat [sl=-1] 585@deftypefnx {Команда MGL} {} refill dat xdat ydat zdat vdat 586@ifclear UDAV 587@deftypefnx {Метод класса @code{mglData}} @code{void} Refill (@code{const mglDataA &}x, @code{const mglDataA &}v, @code{mreal} x1, @code{mreal} x2, @code{long} sl=@code{-1}) 588@deftypefnx {Метод класса @code{mglData}} @code{void} Refill (@code{const mglDataA &}x, @code{const mglDataA &}v, @code{mglPoint} p1, @code{mglPoint} p2, @code{long} sl=@code{-1}) 589@deftypefnx {Метод класса @code{mglData}} @code{void} Refill (@code{const mglDataA &}x, @code{const mglDataA &}y, @code{const mglDataA &}v, @code{mglPoint} p1, @code{mglPoint} p2, @code{long} sl=@code{-1}) 590@deftypefnx {Метод класса @code{mglData}} @code{void} Refill (@code{const mglDataA &}x, @code{const mglDataA &}y, @code{const mglDataA &}z, @code{const mglDataA &}v, @code{mglPoint} p1, @code{mglPoint} p2) 591@deftypefnx {Метод класса @code{mglData}} @code{void} Refill (@code{HMGL} gr, @code{const mglDataA &}x, @code{const mglDataA &}v, @code{long} sl=@code{-1}, @code{const char *}opt=@code{""}) 592@deftypefnx {Метод класса @code{mglData}} @code{void} Refill (@code{HMGL} gr, @code{const mglDataA &}x, @code{const mglDataA &}y, @code{const mglDataA &}v, @code{long} sl=@code{-1}, @code{const char *}opt=@code{""}) 593@deftypefnx {Метод класса @code{mglData}} @code{void} Refill (@code{HMGL} gr, @code{const mglDataA &}x, @code{const mglDataA &}y, @code{const mglDataA &}z, @code{const mglDataA &}v, @code{const char *}opt=@code{""}) 594@deftypefnx {Функция С} @code{void} mgl_data_refill_x (@code{HMDT} a, @code{HCDT} x, @code{HCDT} v, @code{mreal} x1, @code{mreal} x2, @code{long} sl) 595@deftypefnx {Функция С} @code{void} mgl_data_refill_xy (@code{HMDT} a, @code{HCDT} x, @code{HCDT} y, @code{HCDT} v, @code{mreal} x1, @code{mreal} x2, @code{mreal} y1, @code{mreal} y2, @code{long} sl) 596@deftypefnx {Функция С} @code{void} mgl_data_refill_xyz (@code{HMDT} a, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{HCDT} v, @code{mreal} x1, @code{mreal} x2, @code{mreal} y1, @code{mreal} y2, @code{mreal} z1, @code{mreal} z2) 597@deftypefnx {Функция С} @code{void} mgl_data_refill_gr (@code{HMGL} gr, @code{HMDT} a, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{HCDT} v, @code{long} sl, @code{const char *}opt) 598@end ifclear 599Заполняет значениями интерполяции массива @var{v} в точках @{@var{x}, @var{y}, @var{z}@}=@{@code{X[i], Y[j], Z[k]}@} (или @{@var{x}, @var{y}, @var{z}@}=@{@code{X[i,j,k], Y[i,j,k], Z[i,j,k]}@} если @var{x}, @var{y}, @var{z} не 1d массивы), где @code{X,Y,Z} равномерно распределены в диапазоне [@var{x1},@var{x2}]*[@var{y1},@var{y2}]*[@var{z1},@var{z2}] и имеют такой же размер как и заполняемый массив. Если параметр @var{sl} равен 0 или положительный, то изменятся будет только @var{sl}-ый срез. 600@end deftypefn 601 602@anchor{gspline} 603@deftypefn {Команда MGL} {} gspline dat xdat vdat [sl=-1] 604@ifclear UDAV 605@deftypefnx {Метод класса @code{mglData}} @code{void} RefillGS (@code{const mglDataA &}x, @code{const mglDataA &}v, @code{mreal} x1, @code{mreal} x2, @code{long} sl=@code{-1}) 606@deftypefnx {Функция С} @code{void} mgl_data_refill_gs (@code{HMDT} a, @code{HCDT} x, @code{HCDT} v, @code{mreal} x1, @code{mreal} x2, @code{long} sl) 607@end ifclear 608Заполняет значениями глобального кубического сплайна для массива @var{v} в точках @var{x}=@code{X[i]}, где @code{X} равномерно распределен в диапазоне [@var{x1},@var{x2}] и имеет такой же размер как и заполняемый массив. Если параметр @var{sl} равен 0 или положительный, то изменятся будет только @var{sl}-ый срез. 609@end deftypefn 610 611@anchor{idset} 612@deftypefn {Команда MGL} {} idset dat 'ids' 613@ifclear UDAV 614@deftypefnx {Метод класса @code{mglData}} @code{void} SetColumnId (@code{const char *}ids) 615@deftypefnx {Функция С} @code{void} mgl_data_set_id (@code{const char *}ids) 616@deftypefnx {Метод класса @code{mglDataC}} @code{void} SetColumnId (@code{const char *}ids) 617@deftypefnx {Функция С} @code{void} mgl_datac_set_id (@code{HADT} a, @code{const char *}ids) 618@end ifclear 619Задает названия @var{ids} для колонок массива данных. Строка должна содержать один символ 'a'...'z' на колонку. Эти названия используются в функции @ref{column}. 620@end deftypefn 621 622 623 624@anchor{bernoulli} 625@deftypefn {Команда MGL} {} bernoulli dat [@code{p=0.5}] 626@ifclear UDAV 627@deftypefnx {Метод класса @code{mglData}} @code{void} RndBernoulli (@code{mreal} p=0.5) 628@deftypefnx {Функция С} @code{void} mgl_data_rnd_bernoulli (@code{HMDT} dat, @code{mreal} p) 629@deftypefnx {Функция С} @code{mreal} mgl_rnd_bernoulli (@code{mreal} p) 630@end ifclear 631Заполняет массив случайными числами с распределением Бернулли вероятности @var{p}. 632@end deftypefn 633 634@anchor{binomial} 635@deftypefn {Команда MGL} {} binomial dat @code{n [p=0.5]} 636@ifclear UDAV 637@deftypefnx {Метод класса @code{mglData}} @code{void} RndBinomial (@code{long} n, @code{mreal} p=0.5) 638@deftypefnx {Функция С} @code{void} mgl_data_rnd_binomial (@code{HMDT} dat, @code{long} n, @code{mreal} p) 639@deftypefnx {Функция С} @code{mreal} mgl_rnd_binomial (@code{long} n, @code{mreal} p) 640@end ifclear 641Заполняет массив случайными числами с биномиальным распределением в @var{n} бросков с вероятностью @var{p}. 642@end deftypefn 643 644@anchor{brownian} 645@deftypefn {Команда MGL} {} brownian dat @code{y1 y2 sigma h} 646@ifclear UDAV 647@deftypefnx {Метод класса @code{mglData}} @code{void} RndBrownian (@code{mreal} y1, @code{mreal} y2, @code{mreal} sigma, @code{mreal} h) 648@deftypefnx {Функция С} @code{void} mgl_data_rnd_brownian (@code{HMDT} dat, @code{mreal} y1, @code{mreal} y2, @code{mreal} sigma, @code{mreal} h) 649@end ifclear 650Заполняет массив случайным броуновским движением. 651@end deftypefn 652 653@anchor{discrete} 654@deftypefn {Команда MGL} {} discrete dat vdat 655@ifclear UDAV 656@deftypefnx {Метод класса @code{mglData}} @code{void} RndDiscrete (@code{const mglDataA &}vdat) 657@deftypefnx {Функция С} @code{void} mgl_data_rnd_discrete (@code{HMDT} dat, @code{HCDT} vdat) 658@deftypefnx {Функция С} @code{mreal} mgl_rnd_discrete (@code{HCDT} vdat) 659@end ifclear 660Заполняет массив случайными числами с дискретным распределением. 661@end deftypefn 662 663@anchor{exponential} 664@deftypefn {Команда MGL} {} exponential dat [@code{p}] 665@ifclear UDAV 666@deftypefnx {Метод класса @code{mglData}} @code{void} RndExponential (@code{mreal} p) 667@deftypefnx {Функция С} @code{void} mgl_data_rnd_exponential (@code{HMDT} dat, @code{mreal} p) 668@deftypefnx {Функция С} @code{mreal} mgl_rnd_exponential (@code{mreal} p) 669@end ifclear 670Заполняет массив случайными числами с экспоненциальным распределением масштаба @var{p}. 671@end deftypefn 672 673@anchor{gaussian} 674@deftypefn {Команда MGL} {} gaussian dat [@code{mu=0 sigma=1}] 675@ifclear UDAV 676@deftypefnx {Метод класса @code{mglData}} @code{void} RndGaussian (@code{mreal} mu=0, @code{mreal} sigma=1) 677@deftypefnx {Функция С} @code{void} mgl_data_rnd_gaussian (@code{HMDT} dat, @code{mreal} mu, @code{mreal} sigma) 678@deftypefnx {Функция С} @code{mreal} mgl_rnd_gaussian (@code{mreal} mu, @code{mreal} sigma) 679@end ifclear 680Заполняет массив случайными числами с гауссовым распределением со средним @var{mu} и масштабом @var{sigma}. 681@end deftypefn 682 683@anchor{shuffle} 684@deftypefn {Команда MGL} {} shuffle dat ['dir'='a'] 685@ifclear UDAV 686@deftypefnx {Метод класса @code{mglData}} @code{void} RndShuffle (@code{char} dir='a') 687@deftypefnx {Функция С} @code{void} mgl_data_rnd_shuffle (@code{HMDT} dat, @code{char} dir) 688@end ifclear 689Перемешивает содержимое ячеек (для @var{dir}=@samp{a}) или срезов (для @var{dir}=@samp{xyz}). 690@end deftypefn 691 692@anchor{uniform} 693@deftypefn {Команда MGL} {} uniform dat @code{lo hi} 694@ifclear UDAV 695@deftypefnx {Метод класса @code{mglData}} @code{void} RndUniform (@code{mreal} lo, @code{mreal} hi) 696@deftypefnx {Функция С} @code{void} mgl_data_rnd_uniform (@code{HMDT} dat, @code{mreal} lo, @code{mreal} hi) 697@deftypefnx {Функция С} @code{mreal} mgl_rnd_uniform (@code{mreal} lo, @code{mreal} hi) 698@end ifclear 699Заполняет массив случайными числами с равномерным распределением в интервале (@var{lo},@var{hi}). 700@end deftypefn 701 702@anchor{uniformint} 703@deftypefn {Команда MGL} {} uniformint dat @code{lo hi} 704@ifclear UDAV 705@deftypefnx {Метод класса @code{mglData}} @code{void} RndInteger (@code{long} lo, @code{long} hi) 706@deftypefnx {Функция С} @code{void} mgl_data_rnd_integer (@code{HMDT} dat, @code{long} lo, @code{mreal} hi) 707@deftypefnx {Функция С} @code{long} mgl_rnd_integer (@code{long} lo, @code{long} hi) 708@end ifclear 709Заполняет массив случайными целыми числами с равномерным распределением в интервале [@var{lo},@var{hi}). 710@end deftypefn 711 712 713 714 715 716@c ------------------------------------------------------------------ 717@external{} 718@node File I/O, Make another data, Data filling, Data processing 719@section Чтение/сохранение данных 720@nav{} 721@cindex Read 722@cindex ReadMat 723@cindex ReadRange 724@cindex ReadAll 725@cindex Save 726@cindex ReadHDF 727@cindex SaveHDF 728@cindex Import 729@cindex Export 730 731@anchor{read} 732@deftypefn {Команда MGL} {} read @sc{dat} 'fname' 733@deftypefnx {Команда MGL} {} read @sc{redat} @sc{imdat} 'fname' 734@ifclear UDAV 735@deftypefnx {Метод класса @code{mglData}} @code{bool} Read (@code{const char *}fname) 736@deftypefnx {Метод класса @code{mglDataC}} @code{bool} Read (@code{const char *}fname) 737@deftypefnx {Функция С} @code{int} mgl_data_read (@code{HMDT} dat, @code{const char *}fname) 738@deftypefnx {Функция С} @code{int} mgl_datac_read (@code{HADT} dat, @code{const char *}fname) 739@end ifclear 740Читает данные из текстового файла с разделителями символом пробела/табуляции с автоматическим определением размера массива. Двойной перевод строки начинает новый срез данных (по направлению z). 741@end deftypefn 742 743@deftypefn {Команда MGL} {} read @sc{dat} 'fname' @code{mx [my=1 mz=1]} 744@deftypefnx {Команда MGL} {} read @sc{redat} @sc{imdat} 'fname' @code{mx [my=1 mz=1]} 745@ifclear UDAV 746@deftypefnx {Метод класса @code{mglData}} @code{bool} Read (@code{const char *}fname, @code{int} mx, @code{int} my=@code{1}, @code{int} mz=@code{1}) 747@deftypefnx {Метод класса @code{mglDataC}} @code{bool} Read (@code{const char *}fname, @code{int} mx, @code{int} my=@code{1}, @code{int} mz=@code{1}) 748@deftypefnx {Функция С} @code{int} mgl_data_read_dim (@code{HMDT} dat, @code{const char *}fname, @code{int} mx, @code{int} my, @code{int} mz) 749@deftypefnx {Функция С} @code{int} mgl_datac_read_dim (@code{HADT} dat, @code{const char *}fname, @code{int} mx, @code{int} my, @code{int} mz) 750@end ifclear 751Читает данные из текстового файла с заданными размерами. Ничего не делается если параметры @var{mx}, @var{my} или @var{mz} равны нулю или отрицательны. 752@end deftypefn 753 754@anchor{readmat} 755@deftypefn {Команда MGL} {} readmat @sc{dat} 'fname' [@code{dim=2}] 756@ifclear UDAV 757@deftypefnx {Метод класса @code{mglData}} @code{bool} ReadMat (@code{const char *}fname, @code{int} dim=@code{2}) 758@deftypefnx {Метод класса @code{mglDataC}} @code{bool} ReadMat (@code{const char *}fname, @code{int} dim=@code{2}) 759@deftypefnx {Функция С} @code{int} mgl_data_read_mat (@code{HMDT} dat, @code{const char *}fname, @code{int} dim) 760@deftypefnx {Функция С} @code{int} mgl_datac_read_mat (@code{HADT} dat, @code{const char *}fname, @code{int} dim) 761@end ifclear 762Читает данные из текстового файла с размерами, указанными в первых @var{dim} числах файла. При этом переменная @var{dim} задает размерность (1d, 2d, 3d) данных. 763@end deftypefn 764 765@anchor{readall} 766@deftypefn {Команда MGL} {} readall @sc{dat} 'templ' @code{v1 v2 [dv=1 slice=off]} 767@ifclear UDAV 768@deftypefnx {Метод класса @code{mglData}} @code{bool} ReadRange (@code{const char *}templ, @code{mreal} from, @code{mreal} to, @code{mreal} step=@code{1.f}, @code{bool} as_slice=@code{false}) 769@deftypefnx {Метод класса @code{mglDataC}} @code{bool} ReadRange (@code{const char *}templ, @code{mreal} from, @code{mreal} to, @code{mreal} step=@code{1}, @code{bool} as_slice=@code{false}) 770@deftypefnx {Функция С} @code{int} mgl_data_read_range (@code{HMDT} dat, @code{const char *}templ, @code{mreal} from, @code{mreal} to, @code{mreal} step, @code{int} as_slice) 771@deftypefnx {Функция С} @code{int} mgl_datac_read_range (@code{HADT} dat, @code{const char *}templ, @code{mreal} from, @code{mreal} to, @code{mreal} step, @code{int} as_slice) 772@end ifclear 773Объединяет данные из нескольких текстовых файлов. Имена файлов определяются вызовом функции @code{sprintf(fname,templ,val);}, где @var{val} меняется от @var{from} до @var{to} с шагом @var{step}. Данные загружаются один за другим в один и тот же срез данных (при @var{as_slice}=@code{false}) или срез-за-срезом (при @var{as_slice}=@code{true}). 774@end deftypefn 775 776@deftypefn {Команда MGL} {} readall @sc{dat} 'templ' @code{[slice=off]} 777@ifclear UDAV 778@deftypefnx {Метод класса @code{mglData}} @code{bool} ReadAll (@code{const char *}templ, @code{bool} as_slice=@code{false}) 779@deftypefnx {Метод класса @code{mglDataC}} @code{bool} ReadAll (@code{const char *}templ, @code{bool} as_slice=@code{false}) 780@deftypefnx {Функция С} @code{int} mgl_data_read_all (@code{HMDT} dat, @code{const char *}templ, @code{int} as_slice) 781@deftypefnx {Функция С} @code{int} mgl_datac_read_all (@code{HADT} dat, @code{const char *}templ, @code{int} as_slice) 782@end ifclear 783Объединяет данные из нескольких текстовых файлов, чьи имена удовлетворяют шаблону @var{templ} (например, @var{templ}=@code{"t_*.dat"}). Данные загружаются один за другим в один и тот же срез данных (при @var{as_slice}=@code{false}) или срез-за-срезом (при @var{as_slice}=@code{true}). 784@end deftypefn 785 786@anchor{scanfile} 787@deftypefn {Команда MGL} {} scanfile @sc{dat} 'fname' 'templ' 788@ifclear UDAV 789@deftypefnx {Метод класса @code{mglData}} @code{bool} ScanFile (@code{const char *}fname, @code{const char *}templ) 790@deftypefnx {Функция С} @code{int} mgl_data_scan_file (@code{HMDT} dat, @code{const char *}fname, @code{const char *}templ) 791@end ifclear 792Читает файл @var{fname} построчно и каждую строку сканирует на соответствие шаблону @var{templ}. Полученные числа (обозначаются как @samp{%g} в шаблоне) сохраняются. @sref{Saving and scanning file} 793@end deftypefn 794 795@anchor{save} 796@deftypefn {Команда MGL} {} save dat 'fname' 797@ifclear UDAV 798@deftypefnx {Метод класса @code{mglDataA}} @code{void} Save (@code{const char *}fname, @code{int} ns=@code{-1}) @code{const} 799@deftypefnx {Функция С} @code{void} mgl_data_save (@code{HCDT} dat, @code{const char *}fname, @code{int} ns) 800@deftypefnx {Функция С} @code{void} mgl_datac_save (@code{HCDT} dat, @code{const char *}fname, @code{int} ns) 801@end ifclear 802Сохраняет весь массив данных при @var{ns}=@code{-1} или только @var{ns}-ый срез в текстовый файл. 803@end deftypefn 804 805@deftypefn {Команда MGL} {} save @code{val} 'fname' 806Сохраняет значение @var{val} в файл @var{fname}. 807@end deftypefn 808 809@deftypefn {Команда MGL} {} save 'str' 'fname' ['mode'='a'] 810Сохраняет строку @var{str} в файл @var{fname}. Для параметра @var{mode}=@samp{a} происходит добавление строки (по умолчанию): для @var{mode}=@samp{w} файл будет перезаписан. @sref{Saving and scanning file} 811@end deftypefn 812 813@anchor{readhdf} 814@deftypefn {Команда MGL} {} readhdf @sc{dat} 'fname' 'dname' 815@ifclear UDAV 816@deftypefnx {Метод класса @code{mglData}} @code{void} ReadHDF (@code{const char *}fname, @code{const char *}dname) 817@deftypefnx {Метод класса @code{mglDataC}} @code{void} ReadHDF (@code{const char *}fname, @code{const char *}dname) 818@deftypefnx {Функция С} @code{void} mgl_data_read_hdf (@code{HMDT} dat, @code{const char *}fname, @code{const char *}dname) 819@deftypefnx {Функция С} @code{void} mgl_datac_read_hdf (@code{HADT} dat, @code{const char *}fname, @code{const char *}dname) 820@end ifclear 821Читает массив с именем @var{dname} из HDF5 или HDF4 файла @var{fname}. Функция ничего не делает если библиотека была собрана без поддержки HDF5|HDF4. 822@end deftypefn 823 824@anchor{savehdf} 825@deftypefn {Команда MGL} {} savehdf dat 'fname' 'dname' [@code{rewrite}=@code{off}] 826@ifclear UDAV 827@deftypefnx {Метод класса @code{mglDataA}} @code{void} SaveHDF (@code{const char *}fname, @code{const char *}dname, @code{bool} rewrite=@code{false}) @code{const} 828@deftypefnx {Функция С} @code{void} mgl_data_save_hdf (@code{HCDT} dat, @code{const char *}fname, @code{const char *}dname, @code{int} rewrite) 829@deftypefnx {Функция С} @code{void} mgl_datac_save_hdf (@code{HCDT} dat, @code{const char *}fname, @code{const char *}dname, @code{int} rewrite) 830@end ifclear 831Сохраняет массив под именем @var{dname} в HDF5 или HDF4 файл @var{fname}. Функция ничего не делает если библиотека была собрана без поддержки HDF5|HDF4. 832@end deftypefn 833 834@deftypefn {Команда MGL} {} savehdf @code{val} 'fname' 'dname' [@code{rewrite}=@code{off}] 835@ifclear UDAV 836@deftypefnx {Функция С} @code{void} mgl_real_save_hdf (@code{real} val, @code{const char *}fname, @code{const char *}dname, @code{int} rewrite) 837@deftypefnx {Функция С} @code{void} mgl_dual_save_hdf (@code{dual} val, @code{const char *}fname, @code{const char *}dname, @code{int} rewrite) 838@deftypefnx {Функция С} @code{void} mgl_int_save_hdf (@code{long} val, @code{const char *}fname, @code{const char *}dname, @code{int} rewrite) 839@end ifclear 840Сохраняет значение @code{val} под именем @var{dname} в HDF5 файл @var{fname}. Функция ничего не делает если библиотека была собрана без поддержки HDF5. 841@end deftypefn 842 843@anchor{datas} 844@deftypefn {Команда MGL} {} datas 'fname' 845@ifclear UDAV 846@deftypefnx {Метод класса @code{mglDataA}} @code{int} DatasHDF (@code{const char *}fname, @code{char *}buf, @code{long} size) @code{static} 847@deftypefnx {Функция С} @code{void} mgl_datas_hdf (@code{const char *}fname, @code{char *}buf, @code{long} size) 848@end ifclear 849Помещает имена массивов данных в HDF5 файле @var{fname} в строку @var{buf} разделёнными символом табуляции '\t'. В версии MGL имена массивов будут выведены как сообщение. Функция ничего не делает если библиотека была собрана без поддержки HDF5. 850@end deftypefn 851 852@anchor{openhdf} 853@deftypefn {Команда MGL} {} openhdf 'fname' 854@ifclear UDAV 855@deftypefnx {Метод класса @code{mglParse}} @code{void} OpenHDF (@code{const char *}fname) 856@deftypefnx {Функция С} @code{void} mgl_parser_openhdf (@code{HMPR} pr, @code{const char *}fname) 857@end ifclear 858Читает все массивы данных из HDF5 файла @var{fname} и создает переменные MGL с соответствующими именами. Если имя данных начинается с @samp{!}, то будут созданы комплексные массивы. 859@end deftypefn 860 861@ifclear UDAV 862@deftypefn {Функция С} @code{const char * const *} mgl_datas_hdf_str (@code{HMPR} pr, @code{const char *}fname) 863Помещает имена данных из HDF файла @var{fname} в массив строк (последняя строка ""). Массив строк будет изменен при следующем вызове функции. 864@end deftypefn 865@end ifclear 866 867@anchor{import} 868@deftypefn {Команда MGL} {} import @sc{dat} 'fname' 'sch' [@code{v1=0 v2=1}] 869@ifclear UDAV 870@deftypefnx {Метод класса @code{mglData}} @code{void} Import (@code{const char *}fname, @code{const char *}scheme, @code{mreal} v1=@code{0}, mreal v2=@code{1}) 871@deftypefnx {Функция С} @code{void} mgl_data_import (@code{HMDT} dat, @code{const char *}fname, @code{const char *}scheme, @code{mreal} v1, mreal v2) 872@end ifclear 873Читает данные из растрового файла. RGB значения пикселов преобразуются в число в диапазоне [@var{v1}, @var{v2}] используя цветовую схему @var{sch} (@pxref{Color scheme}). 874@end deftypefn 875 876@anchor{export} 877@deftypefn {Команда MGL} {} export dat 'fname' 'sch' [@code{v1=0 v2=0}] 878@ifclear UDAV 879@deftypefnx {Метод класса @code{mglDataA}} @code{void} Export (@code{const char *}fname, @code{const char *}scheme, @code{mreal} v1=@code{0}, mreal v2=@code{0}, @code{int} ns=@code{-1}) const 880@deftypefnx {Функция С} @code{void} mgl_data_export (@code{HMDT} dat, @code{const char *}fname, @code{const char *}scheme, @code{mreal} v1, mreal v2, @code{int} ns) const 881@end ifclear 882Сохраняет данные в растровый файл. Числовые значения, нормированные в диапазон [@var{v1}, @var{v2}], преобразуются в RGB значения пикселов, используя цветовую схему @var{sch} (@pxref{Color scheme}). Если @var{v1}>=@var{v2}, то значения @var{v1}, @var{v2} определяются автоматически как минимальное и максимальное значение данных. 883@end deftypefn 884 885@anchor{readbin} 886@deftypefn {Команда MGL} {} readbin dat 'fname' @code{type} 887@ifclear UDAV 888@deftypefnx {Метод класса @code{mglData}} @code{bool} ReadBin (@code{const char *}fname, @code{int} type) 889@deftypefnx {Функция С} @code{int} mgl_data_read_bin (@code{HMDT} dat, @code{const char *}fname, @code{int} type) 890@end ifclear 891Читает данные из файла в бинарном формате. Параметр @var{type} задает тип данных в файле: 0 - double, 1 - float, 2 - long double, 3 - long int, 4 - int, 5 - short int, 6 - char. Внимание! Эту функцию не рекомендуется использовать с данными, сохраненными на других компьютерах из-за возможных проблем с бинарным представлением чисел. Предпочтительнее использовать HDF формат, см. @ref{readhdf}. 892@end deftypefn 893 894@c ------------------------------------------------------------------ 895@external{} 896@node Make another data, Data changing, File I/O, Data processing 897@section Make another data 898@nav{} 899@cindex SubData 900@cindex Column 901@cindex Trace 902@cindex Hist 903@cindex Resize 904@cindex Evaluate 905@cindex Combine 906@cindex Momentum 907@cindex Sum 908@cindex Min 909@cindex Max 910@cindex Roots 911@cindex Correl 912@cindex AutoCorrel 913 914@anchor{subdata} 915@deftypefn {Команда MGL} {} subdata @sc{res} dat @code{xx [yy=all zz=all]} 916@ifclear UDAV 917@deftypefnx {Метод класса @code{mglData}} @code{mglData} SubData (@code{mreal} xx, @code{mreal} yy=@code{-1}, @code{mreal} zz=@code{-1}) @code{const} 918@deftypefnx {Метод класса @code{mglDataC}} @code{mglData} SubData (@code{mreal} xx, @code{mreal} yy=@code{-1}, @code{mreal} zz=@code{-1}) @code{const} 919@deftypefnx {Функция С} @code{HMDT} mgl_data_subdata (@code{HCDT} dat, @code{mreal} xx, @code{mreal} yy, @code{mreal} zz) 920@end ifclear 921Возвращает в @var{res} подмассив массива данных @var{dat} с фиксированными значениями индексов с положительными значениями. Например, @code{SubData(-1,2)} выделяет третью строку (индексы начинаются с нуля), @code{SubData(4,-1)} выделяет 5-ую колонку, @code{SubData(-1,-1,3)} выделяет 4-ый срез и т.д. В MGL скриптах обычно используется упрощенная версия @code{dat(xx,yy,zz)}. Функция возвращает NULL или пустой массив если данные не могут быть созданы при данных значениях аргументов. 922@end deftypefn 923 924@deftypefn {Команда MGL} {} subdata @sc{res} dat xdat [ydat zdat] 925@ifclear UDAV 926@deftypefnx {Метод класса @code{mglData}} @code{mglData} SubData (@code{const mglDataA &}xx, @code{const mglDataA &}yy, @code{const mglDataA &}zz) @code{const} 927@deftypefnx {Метод класса @code{mglDataC}} @code{mglData} SubData (@code{const mglDataA &}xx, @code{const mglDataA &}yy, @code{const mglDataA &}zz) @code{const} 928@deftypefnx {Функция С} @code{HMDT} mgl_data_subdata_ext (@code{HCDT} dat, @code{HCDT} xx, @code{HCDT} yy, @code{HCDT} zz) 929@end ifclear 930Возвращает в @var{res} подмассив массива данных @var{dat} с индексами, заданными в массивах @var{xx}, @var{yy}, @var{zz} (косвенная адресация). Результат будет иметь размерность массивов с индексами. Размеры массивов @var{xx}, @var{yy}, @var{zz} с индексами должна быть одинакова, либо должны быть "скаляром" (т.е. 1*1*1). В MGL скриптах обычно используется упрощенная версия @code{dat(xx,yy,zz)}. Функция возвращает NULL или пустой массив если данные не могут быть созданы при данных значениях аргументов. 931@end deftypefn 932 933@anchor{column} 934@deftypefn {Команда MGL} {} column @sc{res} dat 'eq' 935@ifclear UDAV 936@deftypefnx {Метод класса @code{mglData}} @code{mglData} Column (@code{const char *}eq) @code{const} 937@deftypefnx {Метод класса @code{mglDataC}} @code{mglData} Column (@code{const char *}eq) @code{const} 938@deftypefnx {Функция С} @code{HMDT} mgl_data_column (@code{HCDT} dat, @code{const char *}eq) 939@end ifclear 940Возвращает массив данных заполненный по формуле @var{eq}, вычисленной для именованных колонок (или срезов). Например, @code{Column("n*w^2/exp(t)");}. Имена колонок должны быть предварительно заданы функцией @ref{idset} или при чтении файлов данных. В MGL скриптах обычно используется упрощенная версия @code{dat('eq')}. Функция возвращает NULL или пустой массив если данные не могут быть созданы при данных значениях аргументов. 941@end deftypefn 942 943@anchor{resize} 944@deftypefn {Команда MGL} {} resize @sc{res} dat @code{mx [my=1 mz=1]} 945@ifclear UDAV 946@deftypefnx {Метод класса @code{mglData}} @code{mglData} Resize (@code{int} mx, @code{int} my=@code{0}, @code{int} mz=@code{0}, @code{mreal} x1=@code{0}, @code{mreal} x2=@code{1}, @code{mreal} y1=@code{0}, @code{mreal} y2=@code{1}, @code{mreal} z1=@code{0}, @code{mreal} z2=@code{1}) @code{const} 947@deftypefnx {Метод класса @code{mglDataC}} @code{mglData} Resize (@code{int} mx, @code{int} my=@code{0}, @code{int} mz=@code{0}, @code{mreal} x1=@code{0}, @code{mreal} x2=@code{1}, @code{mreal} y1=@code{0}, @code{mreal} y2=@code{1}, @code{mreal} z1=@code{0}, @code{mreal} z2=@code{1}) @code{const} 948@deftypefnx {Функция С} @code{HMDT} mgl_data_resize (@code{HCDT} dat, @code{int} mx, @code{int} my, @code{int} mz) 949@deftypefnx {Функция С} @code{HMDT} mgl_data_resize_box (@code{HCDT} dat, @code{int} mx, @code{int} my, @code{int} mz, @code{mreal} x1, @code{mreal} x2, @code{mreal} y1, @code{mreal} y2, @code{mreal} z1, @code{mreal} z2) 950@end ifclear 951Возвращает массив данных размером @var{mx}, @var{my}, @var{mz} со значениями полученными интерполяцией значений из части [@var{x1},@var{x2}] x [@var{y1},@var{y2}] x [@var{z1},@var{z2}] исходного массива. Величины x,y,z полагаются нормированными в диапазоне [0,1]. Если значение @var{mx}, @var{my} или @var{mz} равно 0, то исходный размер используется. Функция возвращает NULL или пустой массив если данные не могут быть созданы при данных значениях аргументов. 952@end deftypefn 953 954@anchor{evaluate} 955@deftypefn {Команда MGL} {} evaluate @sc{res} dat idat [@code{norm=on}] 956@deftypefnx {Команда MGL} {} evaluate @sc{res} dat idat jdat [@code{norm=on}] 957@deftypefnx {Команда MGL} {} evaluate @sc{res} dat idat jdat kdat [@code{norm=on}] 958@ifclear UDAV 959@deftypefnx {Метод класса @code{mglData}} @code{mglData} Evaluate (@code{const mglDataA &}idat, @code{bool} norm=@code{true}) @code{const} 960@deftypefnx {Метод класса @code{mglData}} @code{mglData} Evaluate (@code{const mglDataA &}idat, @code{const mglDataA &}jdat, @code{bool} norm=@code{true}) @code{const} 961@deftypefnx {Метод класса @code{mglData}} @code{mglData} Evaluate (@code{const mglDataA &}idat, @code{const mglDataA &}jdat, @code{const mglDataA &}kdat, @code{bool} norm=@code{true}) @code{const} 962@deftypefnx {Метод класса @code{mglDataC}} @code{mglData} Evaluate (@code{const mglDataA &}idat, @code{bool} norm=@code{true}) @code{const} 963@deftypefnx {Метод класса @code{mglDataC}} @code{mglData} Evaluate (@code{const mglDataA &}idat, @code{const mglDataA &}jdat, @code{bool} norm=@code{true}) @code{const} 964@deftypefnx {Метод класса @code{mglDataC}} @code{mglData} Evaluate (@code{const mglDataA &}idat, @code{const mglDataA &}jdat, @code{const mglDataA &}kdat, @code{bool} norm=@code{true}) @code{const} 965@deftypefnx {Функция С} @code{HMDT} mgl_data_evaluate (@code{HCDT} dat, @code{HCDT} idat, @code{HCDT} jdat, @code{HCDT} kdat, @code{int} norm) 966@end ifclear 967Возвращает массив данных, полученный в результате интерполяции исходного массива в точках других массивов (например, res[i,j]=dat[idat[i,j],jdat[i,j]]). Размеры массивов @var{idat}, @var{jdat}, @var{kdat} должны совпадать. Координаты в @var{idat}, @var{jdat}, @var{kdat} полагаются нормированными в диапазон [0,1] (при @var{norm}=@code{true}) или в диапазоны [0,nx], [0,ny], [0,nz] соответственно. Функция возвращает NULL или пустой массив если данные не могут быть созданы при данных значениях аргументов. 968@end deftypefn 969 970@anchor{section} 971@deftypefn {Команда MGL} {} section @sc{res} dat ids ['dir'='y' @code{val=nan}] 972@deftypefnx {Команда MGL} {} section @sc{res} dat @code{id} ['dir'='y' @code{val=nan}] 973@ifclear UDAV 974@deftypefnx {Метод класса @code{mglData}} @code{mglData} Section (@code{const mglDataA &}ids, @code{const char *}dir=@code{'y'}, @code{mreal} val=@code{NAN}) @code{const} 975@deftypefnx {Метод класса @code{mglData}} @code{mglData} Section (@code{long} id, @code{const char *}dir=@code{'y'}, @code{mreal} val=@code{NAN}) @code{const} 976@deftypefnx {Метод класса @code{mglDataC}} @code{mglData} Section (@code{const mglDataA &}ids, @code{const char *}dir=@code{'y'}, @code{mreal} val=@code{NAN}) @code{const} 977@deftypefnx {Метод класса @code{mglDataC}} @code{mglData} Section (@code{long} id, @code{const char *}dir=@code{'y'}, @code{mreal} val=@code{NAN}) @code{const} 978@deftypefnx {Функция С} @code{HMDT} mgl_data_section (@code{HCDT} dat, @code{HCDT} ids, @code{const char *}dir, @code{mreal} val) 979@deftypefnx {Функция С} @code{HMDT} mgl_data_section_val (@code{HCDT} dat, @code{long} id, @code{const char *}dir, @code{mreal} val) 980@deftypefnx {Функция С} @code{HADT} mgl_datac_section (@code{HCDT} dat, @code{HCDT} ids, @code{const char *}dir, @code{mreal} val) 981@deftypefnx {Функция С} @code{HADT} mgl_datac_section_val (@code{HCDT} dat, @code{long} id, @code{const char *}dir, @code{mreal} val) 982@end ifclear 983Возвращает массив данных, являющийся @var{id}-ой секцией (диапазоном срезов, разделенных значениями @var{val}) исходного массива @var{dat}. Для @var{id}<0 используется обратный порядок (т.e. -1 даст последнюю секцию). Если указано несколько @var{ids}, то выходной массив будет результатом последовательного объединения секций. 984@end deftypefn 985 986@anchor{solve} 987@deftypefn {Команда MGL} {} solve @sc{res} dat @code{val} 'dir' [@code{norm=on}] 988@deftypefnx {Команда MGL} {} solve @sc{res} dat @code{val} 'dir' idat [@code{norm=on}] 989@ifclear UDAV 990@deftypefnx {Метод класса @code{mglData}} @code{mglData} Solve (@code{mreal} val, @code{char} dir, @code{bool} norm=@code{true}) @code{const} 991@deftypefnx {Метод класса @code{mglData}} @code{mglData} Solve (@code{mreal} val, @code{char} dir, @code{const mglDataA &}idat, @code{bool} norm=@code{true}) @code{const} 992@deftypefnx {Функция С} @code{HMDT} mgl_data_solve (@code{HCDT} dat, @code{mreal} val, @code{char} dir, @code{HCDT} idat, @code{int} norm) 993@end ifclear 994Возвращает массив индексов (корней) вдоль выбранного направления @var{dir} в которых значения массива @var{dat} равны @var{val}. Выходной массив будет иметь размеры массива @var{dat} в направлениях поперечных @var{dir}. Если предоставлен массив @var{idat}, то его значения используются как стартовые при поиске. Это позволяет найти несколько веток с помощью последовательного вызова функции. Индексы полагаются нормированными в диапазон [0,1] (при @var{norm}=@code{true}) или в диапазоны [0,nx], [0,ny], [0,nz] соответственно. Функция возвращает NULL или пустой массив если данные не могут быть созданы при данных значениях аргументов. @sref{Solve sample} 995@end deftypefn 996 997@anchor{roots} 998@deftypefn {Команда MGL} {} roots @sc{res} 'func' ini ['var'='x'] 999@deftypefnx {Команда MGL} {} roots @sc{res} 'func' @code{ini} ['var'='x'] 1000@ifclear UDAV 1001@deftypefnx {Метод класса @code{mglData}} @code{mglData} Roots (@code{const char *}func, @code{char} var) @code{const} 1002@deftypefnx {Функция С} @code{HMDT} mgl_data_roots (@code{const char *}func, @code{HCDT} ini, @code{char} var) 1003@deftypefnx {Функция С} @code{mreal} mgl_find_root_txt (@code{const char *}func, @code{mreal} ini, @code{char} var) 1004@end ifclear 1005Возвращает массив корней уравнения 'func'=0 для переменной @var{var} с начальными положениями @var{ini}. Функция возвращает NULL или пустой массив если данные не могут быть созданы при данных значениях аргументов. 1006@end deftypefn 1007 1008@deftypefn {Команда MGL} {} roots @sc{res} 'funcs' 'vars' ini 1009@ifclear UDAV 1010@deftypefnx {Метод класса @code{mglData}} @code{mglData} MultiRoots (@code{const char *}funcs, @code{const char *}vars) @code{const} 1011@deftypefnx {Метод класса @code{mglDataC}} @code{mglDataC} MultiRoots (@code{const char *}funcs, @code{const char *}vars) @code{const} 1012@deftypefnx {Функция С} @code{HMDT} mgl_find_roots_txt (@code{const char *}func, @code{const char *}vars, @code{HCDT} ini) 1013@deftypefnx {Функция С} @code{HADT} mgl_find_roots_txt_c (@code{const char *}func, @code{const char *}vars, @code{HCDT} ini) 1014@end ifclear 1015Возвращает массив корней системы уравнений 'funcs'=0 для переменных @var{vars} с начальными значениями @var{ini}. Функция возвращает NULL или пустой массив если данные не могут быть созданы при данных значениях аргументов. 1016@end deftypefn 1017 1018@anchor{detect} 1019@deftypefn {Команда MGL} {} detect @sc{res} dat @code{lvl dj [di=0 minlen=0]} 1020@ifclear UDAV 1021@deftypefnx {Метод класса @code{mglData}} @code{mglData} Detect (@code{mreal} lvl, @code{mreal} dj, @code{mreal} di=@code{0}, @code{mreal} minlen=@code{0}) @code{const} 1022@deftypefnx {Функция С} @code{HMDT} mgl_data_detect (@code{HCDT} dat, @code{mreal} lvl, @code{mreal} dj, @code{mreal} di, @code{mreal} minlen) 1023@end ifclear 1024Возвращает массив кривых @{x,y@}, разделенных NAN значениями, для локальных максимумов массива @var{dat} как функцию координаты x. Шумы амплитудой меньше @var{lvl} игнорируются. Параметр @var{dj} (в диапазоне [0,ny]) задает область "притяжения" точек в y-направлении к кривой. Аналогично, @var{di} продолжает кривые в x-направлении через разрывы длиной менее @var{di} точек. Кривые с минимальной длинной менее @var{minlen} игнорируются. 1025@end deftypefn 1026 1027@anchor{hist} 1028@deftypefn {Команда MGL} {} hist @sc{res} dat @code{num v1 v2 [nsub=0]} 1029@deftypefnx {Команда MGL} {} hist @sc{res} dat wdat @code{num v1 v2 [nsub=0]} 1030@ifclear UDAV 1031@deftypefnx {Метод класса @code{mglData}} @code{mglData} Hist (@code{int} n, @code{mreal} v1=@code{0}, @code{mreal} v2=@code{1}, @code{int} nsub=@code{0}) @code{const} 1032@deftypefnx {Метод класса @code{mglData}} @code{mglData} Hist (@code{const mglDataA &}w, @code{int} n, @code{mreal} v1=@code{0}, @code{mreal} v2=@code{1}, @code{int} nsub=@code{0}) @code{const} 1033@deftypefnx {Метод класса @code{mglDataC}} @code{mglData} Hist (@code{int} n, @code{mreal} v1=@code{0}, @code{mreal} v2=@code{1}, @code{int} nsub=@code{0}) @code{const} 1034@deftypefnx {Метод класса @code{mglDataC}} @code{mglData} Hist (@code{const mglDataA &}w, @code{int} n, @code{mreal} v1=@code{0}, @code{mreal} v2=@code{1}, @code{int} nsub=@code{0}) @code{const} 1035@deftypefnx {Функция С} @code{HMDT} mgl_data_hist (@code{HCDT} dat, @code{int} n, @code{mreal} v1, @code{mreal} v2, @code{int} nsub) 1036@deftypefnx {Функция С} @code{HMDT} mgl_data_hist_w (@code{HCDT} dat, @code{HCDT} w, @code{int} n, @code{mreal} v1, @code{mreal} v2, @code{int} nsub) 1037@end ifclear 1038Возвращает распределение (гистограмму) из @var{n} точек от значений массива в диапазоне [@var{v1}, @var{v2}]. Массив @var{w} задает веса элементов (по умолчанию все веса равны 1). Параметр @var{nsub} задает число дополнительных точек интерполяции (для сглаживания получившейся гистограммы). Если @var{nsub}<0, то используется линейная интерполяция вместо сплайнов. Функция возвращает NULL или пустой массив если данные не могут быть созданы при данных значениях аргументов. См. также @ref{Data manipulation} 1039@end deftypefn 1040 1041@anchor{momentum} 1042@deftypefn {Команда MGL} {} momentum @sc{res} dat 'how' ['dir'='z'] 1043@ifclear UDAV 1044@deftypefnx {Метод класса @code{mglData}} @code{mglData} Momentum (@code{char} dir, @code{const char *}how) @code{const} 1045@deftypefnx {Метод класса @code{mglDataC}} @code{mglData} Momentum (@code{char} dir, @code{const char *}how) @code{const} 1046@deftypefnx {Функция С} @code{HMDT} mgl_data_momentum (@code{HCDT} dat, @code{char} dir, @code{const char *}how) 1047@end ifclear 1048Возвращает момент (1d массив) данных вдоль направления @var{dir}. Строка @var{how} определяет тип момента. Момент определяется как 1049@iftex 1050@math{res_k = \sum_{ij} how(x_i,y_j,z_k) a_{ij}/\sum_{ij} a_{ij}} 1051@end iftex 1052@ifnottex 1053res_k = \sum_ij how(x_i,y_j,z_k) a_ij/ \sum_ij a_ij 1054@end ifnottex 1055если @var{dir}=@samp{z} и т.д. Координаты @samp{x}, @samp{y}, @samp{z} -- индексы массива в диапазоне [0,1]. Функция возвращает NULL или пустой массив если данные не могут быть созданы при данных значениях аргументов. 1056@end deftypefn 1057 1058@anchor{sum} 1059@deftypefn {Команда MGL} {} sum @sc{res} dat 'dir' 1060@ifclear UDAV 1061@deftypefnx {Метод класса @code{mglData}} @code{mglData} Sum (@code{const char *}dir) @code{const} 1062@deftypefnx {Метод класса @code{mglDataC}} @code{mglData} Sum (@code{const char *}dir) @code{const} 1063@deftypefnx {Функция С} @code{HMDT} mgl_data_sum (@code{HCDT} dat, @code{const char *}dir) 1064@end ifclear 1065Возвращает результат суммирования данных вдоль направления(ий) @var{dir}. Функция возвращает NULL или пустой массив если данные не могут быть созданы при данных значениях аргументов. 1066@end deftypefn 1067 1068@anchor{max} 1069@deftypefn {Команда MGL} {} max @sc{res} dat 'dir' 1070@ifclear UDAV 1071@deftypefnx {Метод класса @code{mglData}} @code{mglData} Max (@code{const char *}dir) @code{const} 1072@deftypefnx {Метод класса @code{mglDataC}} @code{mglData} Max (@code{const char *}dir) @code{const} 1073@deftypefnx {Функция С} @code{HMDT} mgl_data_max_dir (@code{HCDT} dat, @code{const char *}dir) 1074@end ifclear 1075Возвращает максимальное значение данных вдоль направления(ий) @var{dir}. Функция возвращает NULL или пустой массив если данные не могут быть созданы при данных значениях аргументов. 1076@end deftypefn 1077 1078@anchor{min} 1079@deftypefn {Команда MGL} {} min @sc{res} dat 'dir' 1080@ifclear UDAV 1081@deftypefnx {Метод класса @code{mglData}} @code{mglData} Min (@code{const char *}dir) @code{const} 1082@deftypefnx {Метод класса @code{mglDataC}} @code{mglData} Min (@code{const char *}dir) @code{const} 1083@deftypefnx {Функция С} @code{HMDT} mgl_data_min_dir (@code{HCDT} dat, @code{const char *}dir) 1084@end ifclear 1085Возвращает минимальное значение данных вдоль направления(ий) @var{dir}. Функция возвращает NULL или пустой массив если данные не могут быть созданы при данных значениях аргументов. 1086@end deftypefn 1087 1088@anchor{minmax} 1089@deftypefn {Команда MGL} {} minmax @sc{res} dat 1090@ifclear UDAV 1091@deftypefnx {Метод класса @code{mglData}} @code{mglData} MinMax () @code{const} 1092@deftypefnx {Функция С} @code{HMDT} mgl_data_minmax (@code{HCDT} dat) 1093@end ifclear 1094Возвращает положение локальных минимумов и максимумов. Функция возвращает NULL или пустой массив если минимумов и максимумов нет. 1095@end deftypefn 1096 1097@anchor{conts} 1098@deftypefn {Команда MGL} {} conts @sc{res} @code{val} dat 1099@ifclear UDAV 1100@deftypefnx {Метод класса @code{mglData}} @code{mglData} Conts (@code{mreal} val) @code{const} 1101@deftypefnx {Функция С} @code{HMDT} mgl_data_conts (@code{mreal} val, @code{HCDT} dat) 1102@end ifclear 1103Возвращает координаты линий уровня для dat[i,j]=val. Кривые разделяются NAN. Функция возвращает NULL или пустой массив если линий уровня нет. 1104@end deftypefn 1105 1106@anchor{combine} 1107@deftypefn {Команда MGL} {} combine @sc{res} adat bdat 1108@ifclear UDAV 1109@deftypefnx {Метод класса @code{mglData}} @code{mglData} Combine (@code{const mglDataA &}a) @code{const} 1110@deftypefnx {Метод класса @code{mglDataC}} @code{mglData} Combine (@code{const mglDataA &}a) @code{const} 1111@deftypefnx {Функция С} @code{HMDT} mgl_data_combine (@code{HCDT} dat, @code{HCDT} a) 1112@end ifclear 1113Возвращает прямое произведение массивов (наподобие, res[i,j] = adat[i]*bdat[j] и т.д.). Функция возвращает NULL или пустой массив если данные не могут быть созданы при данных значениях аргументов. 1114@end deftypefn 1115 1116@anchor{trace} 1117@deftypefn {Команда MGL} {} trace @sc{res} dat 1118@ifclear UDAV 1119@deftypefnx {Метод класса @code{mglData}} @code{mglData} Trace () @code{const} 1120@deftypefnx {Метод класса @code{mglDataC}} @code{mglData} Trace () @code{const} 1121@deftypefnx {Функция С} @code{HMDT} mgl_data_trace (@code{HCDT} dat) 1122@end ifclear 1123Возвращает массив диагональных элементов a[i,i] (для 2D данных) или a[i,i,i] (для 3D данных) где i=0...nx-1. В 1D случае возвращается сам массив данных. Размеры массива данных должен быть ny,nz >= nx или ny,nz = 1. Функция возвращает NULL или пустой массив если данные не могут быть созданы при данных значениях аргументов. 1124@end deftypefn 1125 1126@anchor{correl} 1127@deftypefn {Команда MGL} {} correl @sc{res} adat bdat 'dir' 1128@ifclear UDAV 1129@deftypefnx {Метод класса @code{mglData}} @code{mglData} Correl (@code{const mglDataA &}b, @code{const char *}dir) @code{const} 1130@deftypefnx {Метод класса @code{mglData}} @code{mglData} AutoCorrel (@code{const char *}dir) @code{const} 1131@deftypefnx {Метод класса @code{mglDataC}} @code{mglDataC} Correl (@code{const mglDataA &}b, @code{const char *}dir) @code{const} 1132@deftypefnx {Метод класса @code{mglDataC}} @code{mglDataC} AutoCorrel (@code{const char *}dir) @code{const} 1133@deftypefnx {Функция С} @code{HMDT} mgl_data_correl (@code{HCDT} a, @code{HCDT} b, @code{const char *}dir) 1134@deftypefnx {Функция С} @code{HADT} mgl_datac_correl (@code{HCDT} a, @code{HCDT} b, @code{const char *}dir) 1135@end ifclear 1136Возвращает корреляцию массивов @var{a} (или this в C++) и @var{b} вдоль направлений @var{dir}. При вычислении используется преобразование Фурье. Поэтому может потребоваться вызов функций @ref{swap} и/или @ref{norm} перед построением. Функция возвращает NULL или пустой массив если данные не могут быть созданы при данных значениях аргументов. 1137@end deftypefn 1138 1139@ifclear UDAV 1140@deftypefn {Метод класса @code{mglDataC}} @code{mglData} Real () @code{const} 1141@deftypefnx {Функция С} @code{HMDT} mgl_datac_real (@code{HCDT} dat) 1142Возвращает массив действительных частей массива данных. 1143@end deftypefn 1144@deftypefn {Метод класса @code{mglDataC}} @code{mglData} Imag () @code{const} 1145@deftypefnx {Функция С} @code{HMDT} mgl_datac_imag (@code{HCDT} dat) 1146Возвращает массив мнимых частей массива данных. 1147@end deftypefn 1148@deftypefn {Метод класса @code{mglDataC}} @code{mglData} Abs () @code{const} 1149@deftypefnx {Функция С} @code{HMDT} mgl_datac_abs (@code{HCDT} dat) 1150Возвращает массив абсолютных значений массива данных. 1151@end deftypefn 1152@deftypefn {Метод класса @code{mglDataC}} @code{mglData} Arg () @code{const} 1153@deftypefnx {Функция С} @code{HMDT} mgl_datac_arg (@code{HCDT} dat) 1154Возвращает массив аргументов массива данных. 1155@end deftypefn 1156@end ifclear 1157 1158@anchor{pulse} 1159@deftypefn {Команда MGL} {} pulse @sc{res} dat 'dir' 1160@ifclear UDAV 1161@deftypefnx {Метод класса @code{mglData}} @code{mglData} Pulse (@code{const char *}dir) @code{const} 1162@deftypefnx {Функция С} @code{HMDT} mgl_data_pulse (@code{HCDT} dat, @code{const char *}dir) 1163@end ifclear 1164Находит параметры импульса вдоль направления @var{dir}: максимальное значение (в колонке 0), его положение (в колонке 1), ширина по параболлической аппроксимации (в колонке 3) и по полувысоте (в колонке 2), энергию около максимума (в колонке 4). NAN значения используются для ширин если максимум расположен вблизи границ массива. Отмечу, что для комплексных массивов есть неопределенность определения параметров. Обычно следует использовать квадрат абсолютного значения амплитуды (т.е. |dat[i]|^2). Поэтому MathGL не включает эту функцию в @code{mglDataC}, хотя формально C функция будет работать и для них, но будет использовать абсолютное значение амплитуды (т.е. |dat[i]|). Функция возвращает NULL или пустой массив если данные не могут быть созданы при данных значениях аргументов. См. также @ref{max}, @ref{min}, @ref{momentum}, @ref{sum}. @sref{Pulse properties} 1165@end deftypefn 1166 1167@anchor{first} 1168@deftypefn {Команда MGL} {} first @sc{res} dat 'dir' @code{val} 1169@ifclear UDAV 1170@deftypefnx {Метод класса @code{mglData}} @code{mglData} First (@code{const char *}dir, @code{mreal} val) @code{const} 1171@deftypefnx {Метод класса @code{mglDataC}} @code{mglData} First (@code{const char *}dir, @code{mreal} val) @code{const} 1172@deftypefnx {Функция С} @code{HMDT} mgl_data_first_dir (@code{HCDT} dat, @code{const char *}dir, @code{mreal} val) 1173@end ifclear 1174Возвращает массив положений ячеек со значениями впервые превысившими @var{val}. Для комплексных данных используется абсолютное значение. См. также @ref{last}. 1175@end deftypefn 1176 1177@anchor{last} 1178@deftypefn {Команда MGL} {} last @sc{res} dat 'dir' @code{val} 1179@ifclear UDAV 1180@deftypefnx {Метод класса @code{mglData}} @code{mglData} Last (@code{const char *}dir, @code{mreal} val) @code{const} 1181@deftypefnx {Метод класса @code{mglDataC}} @code{mglData} Last (@code{const char *}dir, @code{mreal} val) @code{const} 1182@deftypefnx {Функция С} @code{HMDT} mgl_data_last_dir (@code{HCDT} dat, @code{const char *}dir, @code{mreal} val) 1183@end ifclear 1184Возвращает массив положений ячеек со значениями последний раз превысившими @var{val}. Для комплексных данных используется абсолютное значение. См. также @ref{first}. 1185@end deftypefn 1186 1187@ifclear UDAV 1188@deftypefn {Функция С} @code{HMDT} mgl_formula_calc (@code{const char *}str, @code{long} n, ...) 1189@deftypefnx {Функция С} @code{HADT} mgl_formula_calc_c (@code{const char *}str, @code{long} n, ...) 1190Вычисляет формулу @var{str} для заданного списка из @var{n} массивов данных типа @code{HCDT}. Имена переменных соответствуют именам массивов. Возвращенный массив должен быть удален пользователем по окончании использования. См. также @ref{fill}. 1191@end deftypefn 1192@end ifclear 1193 1194@c ------------------------------------------------------------------ 1195@external{} 1196@node Data changing, Interpolation, Make another data, Data processing 1197@section Изменение данных 1198@nav{} 1199@cindex CumSum 1200@cindex Integral 1201@cindex Diff 1202@cindex Diff2 1203@cindex SinFFT 1204@cindex CosFFT 1205@cindex Hankel 1206@cindex Swap 1207@cindex Roll 1208@cindex Mirror 1209@cindex Sew 1210@cindex Smooth 1211@cindex Envelop 1212@cindex Norm 1213@cindex NormSl 1214 1215These functions change the data in some direction like differentiations, integrations and so on. The direction in which the change will applied is specified by the string parameter, which may contain @samp{x}, @samp{y} or @samp{z} characters for 1-st, 2-nd and 3-d dimension correspondingly. 1216 1217@anchor{cumsum} 1218@deftypefn {Команда MGL} {} cumsum dat 'dir' 1219@ifclear UDAV 1220@deftypefnx {Метод класса @code{mglData}} @code{void} CumSum (@code{const char *}dir) 1221@deftypefnx {Метод класса @code{mglDataC}} @code{void} CumSum (@code{const char *}dir) 1222@deftypefnx {Функция С} @code{void} mgl_data_cumsum (@code{HMDT} dat, @code{const char *}dir) 1223@deftypefnx {Функция С} @code{void} mgl_datac_cumsum (@code{HADT} dat, @code{const char *}dir) 1224@end ifclear 1225Суммирует с накоплением в выбранном направлении(ях). 1226@end deftypefn 1227 1228@anchor{integrate} 1229@deftypefn {Команда MGL} {} integrate dat 'dir' 1230@ifclear UDAV 1231@deftypefnx {Метод класса @code{mglData}} @code{void} Integral (@code{const char *}dir) 1232@deftypefnx {Метод класса @code{mglDataC}} @code{void} Integral (@code{const char *}dir) 1233@deftypefnx {Функция С} @code{void} mgl_data_integral (@code{HMDT} dat, @code{const char *}dir) 1234@deftypefnx {Функция С} @code{void} mgl_datac_integral (@code{HADT} dat, @code{const char *}dir) 1235@end ifclear 1236Выполняет интегрирование (методом трапеций) в выбранном направлении(ях). 1237@end deftypefn 1238 1239@anchor{diff} 1240@deftypefn {Команда MGL} {} diff dat 'dir' 1241@ifclear UDAV 1242@deftypefnx {Метод класса @code{mglData}} @code{void} Diff (@code{const char *}dir) 1243@deftypefnx {Метод класса @code{mglDataC}} @code{void} Diff (@code{const char *}dir) 1244@deftypefnx {Функция С} @code{void} mgl_data_diff (@code{HMDT} dat, @code{const char *}dir) 1245@deftypefnx {Функция С} @code{void} mgl_datac_diff (@code{HADT} dat, @code{const char *}dir) 1246@end ifclear 1247Выполняет дифференцирование в выбранном направлении(ях). 1248@end deftypefn 1249 1250@deftypefn {Команда MGL} {} diff dat xdat ydat [zdat] 1251@ifclear UDAV 1252@deftypefnx {Метод класса @code{mglData}} @code{void} Diff (@code{const mglDataA &}x) 1253@deftypefnx {Метод класса @code{mglData}} @code{void} Diff (@code{const mglDataA &}x, @code{const mglDataA &}y) 1254@deftypefnx {Метод класса @code{mglData}} @code{void} Diff (@code{const mglDataA &}x, @code{const mglDataA &}y, @code{const mglDataA &}z) 1255@deftypefnx {Метод класса @code{mglDataC}} @code{void} Diff (@code{const mglDataA &}x) 1256@deftypefnx {Метод класса @code{mglDataC}} @code{void} Diff (@code{const mglDataA &}x, @code{const mglDataA &}y) 1257@deftypefnx {Метод класса @code{mglDataC}} @code{void} Diff (@code{const mglDataA &}x, @code{const mglDataA &}y, @code{const mglDataA &}z) 1258@deftypefnx {Функция С} @code{void} mgl_data_diff_par (@code{HMDT} dat, @code{HCDT} x, @code{HCDT}y, @code{HCDT}z) 1259@deftypefnx {Функция С} @code{void} mgl_datac_diff_par (@code{HADT} dat, @code{HCDT} x, @code{HCDT}y, @code{HCDT}z) 1260@end ifclear 1261Выполняет дифференцирование данных, параметрически зависящих от координат, в направлении @var{x} с @var{y}, @var{z}=constant. Параметр @var{z} может быть опущен, что соответствует 2D случаю. Используются следующие формулы (2D случай): @math{da/dx = (a_j*y_i-a_i*y_j)/(x_j*y_i-x_i*y_j)}, где @math{a_i=da/di, a_j=da/dj} обозначает дифференцирование вдоль 1-ой и 2-ой размерности. Похожие формулы используются и в 3D случае. Порядок аргументов можно менять -- например, если данные a(i,j) зависят от координат @{x(i,j), y(i,j)@}, то обычная производная по @samp{x} будет равна @code{Diff(x,y);}, а обычная производная по @samp{y} будет равна @code{Diff(y,x);}. 1262@end deftypefn 1263 1264@anchor{diff2} 1265@deftypefn {Команда MGL} {} diff2 dat 'dir' 1266@ifclear UDAV 1267@deftypefnx {Метод класса @code{mglData}} @code{void} Diff2 (@code{const char *}dir) 1268@deftypefnx {Метод класса @code{mglDataC}} @code{void} Diff2 (@code{const char *}dir) 1269@deftypefnx {Функция С} @code{void} mgl_data_diff2 (@code{HMDT} dat, @code{const char *}dir) 1270@deftypefnx {Функция С} @code{void} mgl_datac_diff2 (@code{HADT} dat, @code{const char *}dir) 1271@end ifclear 1272Выполняет двойное дифференцирование (как в операторе Лапласа) в выбранном направлении(ях). 1273@end deftypefn 1274 1275@anchor{sinfft} 1276@deftypefn {Команда MGL} {} sinfft dat 'dir' 1277@ifclear UDAV 1278@deftypefnx {Метод класса @code{mglData}} @code{void} SinFFT (@code{const char *}dir) 1279@deftypefnx {Функция С} @code{void} mgl_data_sinfft (@code{HMDT} dat, @code{const char *}dir) 1280@end ifclear 1281Выполняет синус преобразование в выбранном направлении(ях). Синус преобразование есть @math{\sum a_j \sin(k j)} (см. @uref{http://en.wikipedia.org/wiki/Discrete_sine_transform#DST-I}). 1282@end deftypefn 1283 1284@anchor{cosfft} 1285@deftypefn {Команда MGL} {} cosfft dat 'dir' 1286@ifclear UDAV 1287@deftypefnx {Метод класса @code{mglData}} @code{void} CosFFT (@code{const char *}dir) 1288@deftypefnx {Функция С} @code{void} mgl_data_cosfft (@code{HMDT} dat, @code{const char *}dir) 1289@end ifclear 1290Выполняет косинус преобразование в выбранном направлении(ях). Синус преобразование есть @math{\sum a_j \cos(k j)} (см. @uref{http://en.wikipedia.org/wiki/Discrete_cosine_transform#DCT-I}). 1291@end deftypefn 1292 1293@ifclear UDAV 1294@deftypefn {Метод класса @code{mglDataC}} @code{void} FFT (@code{const char *}dir) 1295@deftypefnx {Функция С} @code{void} mgl_datac_fft (@code{HADT} dat, @code{const char *}dir) 1296Выполняет фурье преобразование в выбранном направлении(ях). Если строка @var{dir} содержит @samp{i}, то используется обратное преобразование фурье. Фурье преобразование есть @math{\sum a_j \exp(i k j)} (см. @uref{http://en.wikipedia.org/wiki/Discrete_Fourier_transform}). 1297@end deftypefn 1298@end ifclear 1299 1300@anchor{hankel} 1301@deftypefn {Команда MGL} {} hankel dat 'dir' 1302@ifclear UDAV 1303@deftypefnx {Метод класса @code{mglData}} @code{void} Hankel (@code{const char *}dir) 1304@deftypefnx {Метод класса @code{mglDataC}} @code{void} Hankel (@code{const char *}dir) 1305@deftypefnx {Функция С} @code{void} mgl_data_hankel (@code{HMDT} dat, @code{const char *}dir) 1306@deftypefnx {Функция С} @code{void} mgl_datac_hankel (@code{HADT} dat, @code{const char *}dir) 1307@end ifclear 1308Выполняет преобразование Ханкеля в выбранном направлении(ях). Преобразование Ханкеля есть @math{\sum a_j J_0(k j)} (см. @uref{http://en.wikipedia.org/wiki/Hankel_transform}). 1309@end deftypefn 1310 1311@anchor{wavelet} 1312@deftypefn {Команда MGL} {} wavelet dat 'dir' @code{k} 1313@ifclear UDAV 1314@deftypefnx {Метод класса @code{mglData}} @code{void} Wavelet (@code{const char *}dir, @code{int} k) 1315@deftypefnx {Функция С} @code{void} mgl_data_wavelet (@code{HMDT} dat, @code{const char *}dir, @code{int} k) 1316@end ifclear 1317Выполняет преобразование wavelet в выбранном направлении(ях). Параметр @var{dir} задает тип: 1318@samp{d} для daubechies, @samp{D} для центрированного daubechies, @samp{h} для haar, @samp{H} для центрированного haar, @samp{b} для bspline, @samp{B} для центрированного bspline. Если указан символ @samp{i}, то выполняется обратное преобразование. Параметр @var{k} задает размер преобразования. 1319@end deftypefn 1320 1321@anchor{swap} 1322@deftypefn {Команда MGL} {} swap dat 'dir' 1323@ifclear UDAV 1324@deftypefnx {Метод класса @code{mglData}} @code{void} Swap (@code{const char *}dir) 1325@deftypefnx {Метод класса @code{mglDataC}} @code{void} Swap (@code{const char *}dir) 1326@deftypefnx {Функция С} @code{void} mgl_data_swap (@code{HMDT} dat, @code{const char *}dir) 1327@deftypefnx {Функция С} @code{void} mgl_datac_swap (@code{HADT} dat, @code{const char *}dir) 1328@end ifclear 1329Меняет местами левую и правую части данных в выбранном направлении(ях). Полезно для отображения результата FFT. 1330@end deftypefn 1331 1332@anchor{roll} 1333@deftypefn {Команда MGL} {} roll dat 'dir' num 1334@ifclear UDAV 1335@deftypefnx {Метод класса @code{mglData}} @code{void} Roll (@code{char} dir, @code{num}) 1336@deftypefnx {Метод класса @code{mglDataC}} @code{void} Roll (@code{char} dir, @code{num}) 1337@deftypefnx {Функция С} @code{void} mgl_data_roll (@code{HMDT} dat, @code{char} dir, @code{num}) 1338@deftypefnx {Функция С} @code{void} mgl_datac_roll (@code{HADT} dat, @code{char} dir, @code{num}) 1339@end ifclear 1340Сдвигает данные на @var{num} ячеек в выбранном направлении(ях). Соответствует замене индекса на @var{i}->(i+@var{num})%nx при @code{dir='x'}. 1341@end deftypefn 1342 1343@anchor{mirror} 1344@deftypefn {Команда MGL} {} mirror dat 'dir' 1345@ifclear UDAV 1346@deftypefnx {Метод класса @code{mglData}} @code{void} Mirror (@code{const char *}dir) 1347@deftypefnx {Метод класса @code{mglDataC}} @code{void} Mirror (@code{const char *}dir) 1348@deftypefnx {Функция С} @code{void} mgl_data_mirror (@code{HMDT} dat, @code{const char *}dir) 1349@deftypefnx {Функция С} @code{void} mgl_datac_mirror (@code{HADT} dat, @code{const char *}dir) 1350@end ifclear 1351Отражает данные в выбранном направлении(ях). Соответствует замене индекса на @var{i}->@var{n}-@var{i}. Отмечу, что похожего эффекта на графике можно достичь используя опции (@pxref{Command options}), например, @code{surf dat; xrange 1 -1}. 1352@end deftypefn 1353 1354@anchor{sew} 1355@deftypefn {Команда MGL} {} sew dat ['dir'='xyz' @code{da=2*pi}] 1356@ifclear UDAV 1357@deftypefnx {Метод класса @code{mglData}} @code{void} Sew (@code{const char *}dir, @code{mreal} da=@code{2*M_PI}) 1358@deftypefnx {Функция С} @code{void} mgl_data_sew (@code{HMDT} dat, @code{const char *}dir, @code{mreal} da) 1359@end ifclear 1360Удаляет скачки данных (например, скачки фазы после обратных тригонометрических функций) с периодом @var{da} в выбранном направлении(ях). 1361@end deftypefn 1362 1363@anchor{smooth} 1364@deftypefn {Команда MGL} {} smooth data ['dir'='xyz'] 1365@ifclear UDAV 1366@deftypefnx {Метод класса @code{mglData}} @code{void} Smooth (@code{const char *}dir=@code{"xyz"}, @code{mreal} delta=@code{0}) 1367@deftypefnx {Метод класса @code{mglDataC}} @code{void} Smooth (@code{const char *}dir=@code{"xyz"}, @code{mreal} delta=@code{0}) 1368@deftypefnx {Функция С} @code{void} mgl_data_smooth (@code{HMDT} dat, @code{const char *}dir, @code{mreal} delta) 1369@deftypefnx {Функция С} @code{void} mgl_datac_smooth (@code{HADT} dat, @code{const char *}dir, @code{mreal} delta) 1370@end ifclear 1371Сглаживает данные в выбранном направлении(ях) @var{dir}. Строка @var{dirs} задает направления вдоль которых будет производиться сглаживание. Строка @var{dir} может содержать: 1372@itemize @bullet 1373@item 1374@samp{xyz} -- сглаживание по x-,y-,z-направлениям, 1375@item 1376@samp{0} -- ничего не делает, 1377@item 1378@samp{3} -- линейное усреднение по 3 точкам, 1379@item 1380@samp{5} -- линейное усреднение по 5 точкам, 1381@item 1382@samp{d1}...@samp{d9} -- линейное усреднение по (2*N+1) точкам, 1383@item 1384@samp{p1}...@samp{p9} -- параболличсеское усреднение по (2*N+1) точкам, 1385@item 1386@samp{^} -- определение верхней границы, 1387@item 1388@samp{_} -- определение нижней границы. 1389@end itemize 1390По умолчанию используется квадратичное усреднение по 5 точкам. 1391@end deftypefn 1392 1393@anchor{envelop} 1394@deftypefn {Команда MGL} {} envelop dat ['dir'='x'] 1395@ifclear UDAV 1396@deftypefnx {Метод класса @code{mglData}} @code{void} Envelop (@code{char} dir=@code{'x'}) 1397@deftypefnx {Функция С} @code{void} mgl_data_envelop (@code{HMDT} dat, @code{char} dir) 1398@end ifclear 1399Находит огибающую данных в выбранном направлении @var{dir}. 1400@end deftypefn 1401 1402@anchor{diffract} 1403@deftypefn {Команда MGL} {} diffract dat 'how' @code{q} 1404@ifclear UDAV 1405@deftypefnx {Метод класса @code{mglDataC}} @code{void} Diffraction (@code{const char *}how, @code{mreal} q) 1406@deftypefnx {Функция С} @code{void} mgl_datac_diffr (@code{HADT} dat, @code{const char *}how, @code{mreal} q) 1407@end ifclear 1408Вычисляет один шаг диффракции в конечно-разностной схеме с параметром @var{q}=@math{\delta t/\delta x^2} используя метод третьего порядка точности. Параметр @var{how} может содержать: 1409@itemize @bullet 1410 @item @samp{xyz} для расчета вдоль x-,y-,z-направления; 1411@item 1412 @samp{r} для аксиально симметричного лапласиана по направлению x; 1413@item 1414 @samp{0} для нулевых граничных условий; 1415@item 1416 @samp{1} для постоянных граничных условий; 1417@item 1418 @samp{2} для линейных граничных условий; 1419@item 1420 @samp{3} для параболлических граничных условий; 1421@item 1422 @samp{4} для экспоненциальных граничных условий; 1423@item 1424 @samp{5} для гауссовых граничных условий. 1425@end itemize 1426@end deftypefn 1427 1428@anchor{norm} 1429@deftypefn {Команда MGL} {} norm dat @code{v1 v2 [sym=off dim=0]} 1430@ifclear UDAV 1431@deftypefnx {Метод класса @code{mglData}} @code{void} Norm (@code{mreal} v1=@code{0}, @code{mreal} v2=@code{1}, @code{bool} sym=@code{false}, @code{long} dim=@code{0}) 1432@deftypefnx {Функция С} @code{void} mgl_data_norm (@code{HMDT} dat, @code{mreal} v1, @code{mreal} v2, @code{int} sym, @code{long} dim) 1433@end ifclear 1434Нормирует данные в интервал [@var{v1},@var{v2}]. Если @var{sym}=@code{true}, то используется симметричный интервал [-max(|v1|,|v2|), max(|v1|,|v2|)]. Изменения применяются только к срезам >=@var{dim}. 1435@end deftypefn 1436 1437@anchor{normsl} 1438@deftypefn {Команда MGL} {} normsl dat @code{v1 v2} ['dir'='z' @code{keep=on sym=off}] 1439@ifclear UDAV 1440@deftypefnx {Метод класса @code{mglData}} @code{void} NormSl (@code{mreal} v1=@code{0}, @code{mreal} v2=@code{1}, @code{char} dir=@code{'z'}, @code{bool} keep=@code{true}, @code{bool} sym=@code{false}) 1441@deftypefnx {Функция С} @code{void} mgl_data_norm_slice (@code{HMDT} dat, @code{mreal} v1, @code{mreal} v2, @code{char} dir, @code{int} keep, @code{int} sym) 1442@end ifclear 1443Нормирует данные срез-за-срезом в выбранном направлении @var{dir} в интервал [@var{v1},@var{v2}]. Если @var{sym}=@code{true}, то используется симметричный интервал [-max(|v1|,|v2|), max(|v1|,|v2|)]. Если @var{keep}=@code{true}, то максимальное значение k-го среза ограничено величиной 1444@iftex 1445@math{\sqrt{\sum a_{ij}(k)/\sum a_{ij}(0)}}. 1446@end iftex 1447@ifnottex 1448@math{\sqrt@{\sum a_ij(k)/\sum a_ij(0)@}}. 1449@end ifnottex 1450@end deftypefn 1451 1452@anchor{keep} 1453@deftypefn {Команда MGL} {} keep dat 'dir' @code{i [j=0]} 1454@ifclear UDAV 1455@deftypefnx {Метод класса @code{mglData}} @code{void} Keep (@code{const char *}dir, @code{long} i, @code{long} j=0) 1456@deftypefnx {Метод класса @code{mglDataC}} @code{void} Keep (@code{const char *}dir, @code{long} i, @code{long} j=0) 1457@deftypefnx {Функция С} @code{void} mgl_data_keep (@code{HMDT} dat, @code{const char *}dir, @code{long} i, @code{long} j) 1458@deftypefnx {Функция С} @code{void} mgl_datac_keep (@code{HADT} dat, @code{const char *}dir, @code{long} i, @code{long} j=0) 1459@end ifclear 1460Ограничивает изменение фазы/знака или амплитуды (если @var{dir} содержит @samp{a}) данных вдоль направления @var{dir} фиксируя значение в точке @{@var{i},@var{j}@} начального среза. Функция полезна для удаления общего набега фазы в комплексных данных. @sref{keep sample} 1461@end deftypefn 1462 1463 1464@anchor{limit} 1465@deftypefn {Команда MGL} {} limit dat @code{val} 1466@ifclear UDAV 1467@deftypefnx {Метод класса @code{mglData}} @code{void} Limit (@code{mreal} val) 1468@deftypefnx {Метод класса @code{mglDataC}} @code{void} Limit (@code{mreal} val) 1469@deftypefnx {Функция С} @code{void} mgl_data_limit (@code{HMDT} dat, @code{mreal} val) 1470@deftypefnx {Функция С} @code{void} mgl_datac_limit (@code{HADT} dat, @code{mreal} val) 1471@end ifclear 1472Ограничивает амплитуду данных диапазоном [-@var{val},@var{val}]. При этом сохраняется исходный знак (фаза для комплексных чисел). Эквивалентно операции @code{a[i] *= abs(a[i])<val?1.:val/abs(a[i]);}. 1473@end deftypefn 1474 1475@anchor{coil} 1476@deftypefn {Команда MGL} {} coil dat @code{v1 v2 [sep=on]} 1477@ifclear UDAV 1478@deftypefnx {Метод класса @code{mglData}} @code{void} Coil (@code{mreal} v1, @code{mreal} v2, @code{bool} sep=@code{true}) 1479@deftypefnx {Функция С} @code{void} mgl_data_coil (@code{HMDT} dat, @code{mreal} v1, @code{mreal} v2, @code{int} sep) 1480@end ifclear 1481Проецирует периодические данные на диапазон [@var{v1},@var{v2}] (аналогично функции @code{mod()}). Разделяет ветки по значениям равным @code{NAN} если @var{sep}=@code{true}. 1482@end deftypefn 1483 1484@anchor{dilate} 1485@deftypefn {Команда MGL} {} dilate dat @code{[val=1 step=1]} 1486@ifclear UDAV 1487@deftypefnx {Метод класса @code{mglData}} @code{void} Dilate (@code{mreal} val=@code{1}, @code{long} step=@code{1}) 1488@deftypefnx {Функция С} @code{void} mgl_data_dilate (@code{HMDT} dat, @code{mreal} val, @code{long} step) 1489@end ifclear 1490Возвращает "расширенный" на @var{step} ячеек массив из 0 и 1 для данных больших порогового значения @var{val}. @c TODO @sref{Dilate and erode sample} 1491@end deftypefn 1492 1493@anchor{erode} 1494@deftypefn {Команда MGL} {} erode dat @code{[val=1 step=1]} 1495@ifclear UDAV 1496@deftypefnx {Метод класса @code{mglData}} @code{void} Erode (@code{mreal} val=@code{1}, @code{long} step=@code{1}) 1497@deftypefnx {Функция С} @code{void} mgl_data_erode (@code{HMDT} dat, @code{mreal} val, @code{long} step) 1498@end ifclear 1499Возвращает "суженный" на @var{step} ячеек массив из 0 и 1 для данных больших порогового значения @var{val}. @c TODO @sref{Dilate and erode sample} 1500@end deftypefn 1501 1502@c ------------------------------------------------------------------ 1503@external{} 1504@node Interpolation, Data information, Data changing, Data processing 1505@section Интерполяция 1506@nav{} 1507 1508Скрипты MGL могут использовать интерполяцию кубическими сплайнами с помощью команд @ref{evaluate} или @ref{refill}. Также можно использовать @ref{resize} для массива с новыми размерами. 1509 1510@ifclear UDAV 1511 1512Однако, есть специальные и более быстрые функции при использовании других языков (C/C++/Fortran/Python/...). 1513 1514@cindex Spline 1515@deftypefn {Метод класса @code{mglData}} @code{mreal} Spline (@code{mreal} x, @code{mreal} y=@code{0}, @code{mreal} z=@code{0}) @code{const} 1516@deftypefnx {Метод класса @code{mglDataC}} @code{dual} Spline (@code{mreal} x, @code{mreal} y=@code{0}, @code{mreal} z=@code{0}) @code{const} 1517@deftypefnx {Функция С} @code{mreal} mgl_data_spline (@code{HCDT} dat, @code{mreal} x, @code{mreal} y, @code{mreal} z) 1518@deftypefnx {Функция С} @code{dual} mgl_datac_spline (@code{HCDT} dat, @code{mreal} x, @code{mreal} y, @code{mreal} z) 1519Интерполирует данные кубическим сплайном в точке @var{x} в [0...nx-1], @var{y} в [0...ny-1], @var{z} в [0...nz-1]. 1520@end deftypefn 1521@cindex Spline1 1522@deftypefn {Метод класса @code{mglData}} @code{mreal} Spline1 (@code{mreal} x, @code{mreal} y=@code{0}, @code{mreal} z=@code{0}) @code{const} 1523@deftypefnx {Метод класса @code{mglDataC}} @code{dual} Spline1 (@code{mreal} x, @code{mreal} y=@code{0}, @code{mreal} z=@code{0}) @code{const} 1524Интерполирует данные кубическим сплайном в точке @var{x}, @var{y}, @var{z}, где координаты полагаются в интервале [0, 1]. 1525@end deftypefn 1526 1527@deftypefn {Метод класса @code{mglData}} @code{mreal} Spline (@code{mglPoint} &dif, @code{mreal} x, @code{mreal} y=@code{0}, @code{mreal} z=@code{0}) @code{const} 1528@deftypefnx {Функция С} @code{mreal} mgl_data_spline_ext (@code{HCDT} dat, @code{mreal} x, @code{mreal} y, @code{mreal} z, @code{mreal *}dx, @code{mreal *}dy, @code{mreal *}dz) 1529@deftypefnx {Функция С} @code{dual} mgl_datac_spline_ext (@code{HCDT} dat, @code{mreal} x, @code{mreal} y, @code{mreal} z, @code{dual *}dx, @code{dual *}dy, @code{dual *}dz) 1530Интерполирует данные кубическим сплайном в точке @var{x} в [0...nx-1], @var{y} в [0...ny-1], @var{z} в [0...nz-1]. Значения производных в точке записываются в @var{dif}. 1531@end deftypefn 1532@cindex Spline1 1533@deftypefn {Метод класса @code{mglData}} @code{mreal} Spline1 (@code{mglPoint} &dif, @code{mreal} x, @code{mreal} y=@code{0}, @code{mreal} z=@code{0}) @code{const} 1534Интерполирует данные кубическим сплайном в точке @var{x}, @var{y}, @var{z}, где координаты полагаются в интервале [0, 1]. Значения производных в точке записываются в @var{dif}. 1535@end deftypefn 1536 1537 1538@cindex Linear 1539@deftypefn {Метод класса @code{mglData}} @code{mreal} Linear (@code{mreal} x, @code{mreal} y=@code{0}, @code{mreal} z=@code{0}) @code{const} 1540@deftypefnx {Метод класса @code{mglDataC}} @code{dual} Linear (@code{mreal} x, @code{mreal} y=@code{0}, @code{mreal} z=@code{0}) @code{const} 1541@deftypefnx {Функция С} @code{mreal} mgl_data_linear (@code{HCDT} dat, @code{mreal} x, @code{mreal} y, @code{mreal} z) 1542@deftypefnx {Функция С} @code{dual} mgl_datac_linear (@code{HCDT} dat, @code{mreal} x, @code{mreal} y, @code{mreal} z) 1543Интерполирует данные линейной функцией в точке @var{x} в [0...nx-1], @var{y} в [0...ny-1], @var{z} в [0...nz-1]. 1544@end deftypefn 1545@cindex Linear1 1546@deftypefn {Метод класса @code{mglData}} @code{mreal} Linear1 (@code{mreal} x, @code{mreal} y=@code{0}, @code{mreal} z=@code{0}) @code{const} 1547@deftypefnx {Метод класса @code{mglDataC}} @code{dual} Linear1 (@code{mreal} x, @code{mreal} y=@code{0}, @code{mreal} z=@code{0}) @code{const} 1548Интерполирует данные линейной функцией в точке @var{x}, @var{y}, @var{z}, где координаты полагаются в интервале [0, 1]. 1549@end deftypefn 1550 1551@deftypefn {Метод класса @code{mglData}} @code{mreal} Linear (@code{mglPoint} &dif, @code{mreal} x, @code{mreal} y=@code{0}, @code{mreal} z=@code{0}) @code{const} 1552@deftypefnx {Метод класса @code{mglDataC}} @code{dual} Linear (@code{mglPoint} &dif, @code{mreal} x, @code{mreal} y=@code{0}, @code{mreal} z=@code{0}) @code{const} 1553@deftypefnx {Функция С} @code{mreal} mgl_data_linear_ext (@code{HCDT} dat, @code{mreal} x, @code{mreal} y, @code{mreal} z, @code{mreal *}dx, @code{mreal *}dy, @code{mreal *}dz) 1554@deftypefnx {Функция С} @code{dual} mgl_datac_linear_ext (@code{HCDT} dat, @code{mreal} x, @code{mreal} y, @code{mreal} z, @code{dual *}dx, @code{dual *}dy, @code{dual *}dz) 1555Интерполирует данные линейной функцией в точке @var{x}, @var{y}, @var{z}, где координаты полагаются в интервале [0, 1]. Значения производных в точке записываются в @var{dif}. 1556@end deftypefn 1557@cindex Linear1 1558@deftypefn {Метод класса @code{mglData}} @code{mreal} Linear1 (@code{mglPoint} &dif, @code{mreal} x, @code{mreal} y=@code{0}, @code{mreal} z=@code{0}) @code{const} 1559@deftypefnx {Метод класса @code{mglDataC}} @code{dual} Linear1 (@code{mglPoint} &dif, @code{mreal} x, @code{mreal} y=@code{0}, @code{mreal} z=@code{0}) @code{const} 1560Интерполирует данные линейной функцией в точке @var{x}, @var{y}, @var{z}, где координаты полагаются в интервале [0, 1]. Значения производных в точке записываются в @var{dif}. 1561@end deftypefn 1562 1563@end ifclear 1564 1565@c ------------------------------------------------------------------ 1566@external{} 1567@node Data information, Operators, Interpolation, Data processing 1568@section Информационные функции 1569@nav{} 1570 1571В MathGL есть ряд функций для получения свойств массива данных. В MGL скриптах большинство из них реализовано в виде "суффиксов". Суффиксы дают числовое значение некоторой характеристики массива данных. Например, его размер, минимальное и максимальное значение, сумму элементов и т.д. Суффиксы начинаются с точки @samp{.} сразу после массива (без пробелов). Например, @code{a.nx} даст размер массива @var{a} вдоль x, @code{b(1).max} даст максимальное значение второй колонки массива @var{b}, @code{(c(:,0)^2).sum} даст сумму квадратов в первой строке массива @var{c} и т.д. 1572 1573 1574@cindex PrintInfo 1575@anchor{info} 1576@deftypefn {Команда MGL} {} info dat 1577@ifclear UDAV 1578@deftypefnx {Метод класса @code{mglDataA}} @code{const char *} PrintInfo () @code{const} 1579@deftypefnx {Метод класса @code{mglDataA}} @code{void} PrintInfo (@code{FILE *}fp) @code{const} 1580@deftypefnx {Функция С} @code{const char *} mgl_data_info (@code{HCDT} dat) 1581@deftypefnx {Fortran процедура} @code{} mgl_data_info (@code{long} dat, @code{char *}out, @code{int} len) 1582@end ifclear 1583Возвращает строку с информацией о данных (размеры, моменты и пр.) или пишет её в файл. В MGL скрипте печатает её как сообщение. 1584@end deftypefn 1585 1586@deftypefn {Команда MGL} {} info 'txt' 1587Печатает строку @var{txt} как сообщение. 1588@end deftypefn 1589 1590@deftypefn {Команда MGL} {} info val 1591Печатает значение числа @var{val} как сообщение. 1592@end deftypefn 1593 1594@anchor{print} 1595@deftypefn {Команда MGL} {} print dat 1596@deftypefnx {Команда MGL} {} print 'txt' 1597@deftypefnx {Команда MGL} {} print val 1598Аналогично @ref{info}, но сразу выводит в stdout. 1599@end deftypefn 1600 1601@anchor{echo} 1602@deftypefn {Команда MGL} {} echo dat 1603Печатает все значения массива @var{dat} как сообщение. 1604@end deftypefn 1605 1606@anchor{progress} 1607@deftypefn {Команда MGL} {} progress @code{val max} 1608@ifclear UDAV 1609@deftypefnx {Метод класса @code{mglGraph}} @code{void} Progress (@code{int} val, @code{int} max) 1610@deftypefnx {Функция С} @code{void} mgl_progress (@code{int} val, @code{int} max) 1611@end ifclear 1612Отображает прогресс чего-либо как заполненную полоску с относительной длиной @var{val}/@var{max}. На данный момент работает только в консоли и основанных на FLTK программах, включая @code{mgllab} и @code{mglview}. 1613@end deftypefn 1614 1615 1616@cindex GetNx 1617@cindex GetNy 1618@cindex GetNz 1619@anchor{.nx} @anchor{.ny} @anchor{.nz} 1620@deftypefn {MGL suffix} {(dat)} .nx 1621@deftypefnx {MGL suffix} {(dat)} .ny 1622@deftypefnx {MGL suffix} {(dat)} .nz 1623@ifclear UDAV 1624@deftypefnx {Метод класса @code{mglDataA}} @code{long} GetNx () 1625@deftypefnx {Метод класса @code{mglDataA}} @code{long} GetNy () 1626@deftypefnx {Метод класса @code{mglDataA}} @code{long} GetNz () 1627@deftypefnx {Функция С} @code{long} mgl_data_get_nx (@code{HCDT} dat) 1628@deftypefnx {Функция С} @code{long} mgl_data_get_ny (@code{HCDT} dat) 1629@deftypefnx {Функция С} @code{long} mgl_data_get_nz (@code{HCDT} dat) 1630@end ifclear 1631Возвращает размер данных в направлении x, y и z соответственно. 1632@end deftypefn 1633 1634 1635 1636@cindex Maximal 1637@anchor{.max} 1638@deftypefn {MGL suffix} {(dat)} .max 1639@ifclear UDAV 1640@deftypefnx {Метод класса @code{mglDataA}} @code{mreal} Maximal () @code{const} 1641@deftypefnx {Функция С} @code{mreal} mgl_data_max (@code{HCDT} dat) 1642@end ifclear 1643Возвращает максимальное значение массива данных. 1644@end deftypefn 1645 1646@cindex Minimal 1647@anchor{.min} 1648@deftypefn {MGL suffix} {(dat)} .min 1649@ifclear UDAV 1650@deftypefnx {Метод класса @code{mglDataA}} @code{mreal} Minimal () @code{const} 1651@deftypefnx {Функция С} @code{mreal} mgl_data_min (@code{HMDT} dat) @code{const} 1652@end ifclear 1653Возвращает минимальное значение массива данных. 1654@end deftypefn 1655 1656@ifclear UDAV 1657@deftypefn {Метод класса @code{mglDataA}} @code{mreal} Minimal (@code{int} &i, @code{int} &j, @code{int} &k) @code{const} 1658@deftypefnx {Функция С} @code{mreal} mgl_data_min_int (@code{HCDT} dat, @code{int} *i, @code{int} *j, @code{int} *k) 1659Возвращает максимальное значение массива данных и сохраняет его положение в переменные @var{i}, @var{j}, @var{k}. 1660@end deftypefn 1661@deftypefn {Метод класса @code{mglDataA}} @code{mreal} Maximal (@code{int} &i, @code{int} &j, @code{int} &k) @code{const} 1662@deftypefnx {Функция С} @code{mreal} mgl_data_max_int (@code{HCDT} dat, @code{int} *i, @code{int} *j, @code{int} *k) 1663Возвращает минимальное значение массива данных и сохраняет его положение в переменные @var{i}, @var{j}, @var{k}. 1664@end deftypefn 1665@deftypefn {Метод класса @code{mglDataA}} @code{mreal} Minimal (@code{mreal} &x, @code{mreal} &y, @code{mreal} &z) @code{const} 1666@deftypefnx {Функция С} @code{mreal} mgl_data_min_real (@code{HCDT} dat, @code{mreal} *x, @code{mreal} *y, @code{mreal} *z) 1667Возвращает максимальное значение массива данных и его приближенное (интерполированное) положение в переменные @var{x}, @var{y}, @var{z}. 1668@end deftypefn 1669@end ifclear 1670 1671@anchor{.mx} @anchor{.my} @anchor{.mz} 1672@deftypefn {MGL suffix} {(dat)} .mx 1673@deftypefnx {MGL suffix} {(dat)} .my 1674@deftypefnx {MGL suffix} {(dat)} .mz 1675@ifclear UDAV 1676@deftypefnx {Метод класса @code{mglDataA}} @code{mreal} Maximal (@code{mreal} &x, @code{mreal} &y, @code{mreal} &z) @code{const} 1677@deftypefnx {Функция С} @code{mreal} mgl_data_max_real (@code{HCDT} dat, @code{mreal} *x, @code{mreal} *y, @code{mreal} *z) 1678@end ifclear 1679Возвращает минимальное значение массива данных и его приближенное (интерполированное) положение в переменные @var{x}, @var{y}, @var{z}. 1680@end deftypefn 1681 1682@anchor{.mxf} @anchor{.myf} @anchor{.mzf} 1683@anchor{.mxl} @anchor{.myl} @anchor{.mzl} 1684@deftypefn {MGL suffix} {(dat)} .mxf 1685@deftypefnx {MGL suffix} {(dat)} .myf 1686@deftypefnx {MGL suffix} {(dat)} .mzf 1687@deftypefnx {MGL suffix} {(dat)} .mxl 1688@deftypefnx {MGL suffix} {(dat)} .myl 1689@deftypefnx {MGL suffix} {(dat)} .mzl 1690@ifclear UDAV 1691@deftypefnx {Метод класса @code{mglDataA}} @code{long} Maximal (@code{char} dir, @code{long} from) @code{const} 1692@deftypefnx {Метод класса @code{mglDataA}} @code{long} Maximal (@code{char} dir, @code{long} from, @code{long} &p1, @code{long} &p2) @code{const} 1693@deftypefnx {Функция С} @code{mreal} mgl_data_max_firstl (@code{HCDT} dat, @code{char} dir, @code{long} from, @code{long} *p1, @code{long} *p2) 1694@end ifclear 1695Возвращает положение первого (последнего при @var{from}<0) максимума в направлении @var{dir}, начиная с позиции @var{from}. Положение остальных координат для максимума сохраняется в @var{p1}, @var{p2}. 1696@end deftypefn 1697 1698 1699@cindex Momentum 1700@anchor{.ax} @anchor{.ay} @anchor{.az} @anchor{.aa} @anchor{.sum} 1701@anchor{.wx} @anchor{.wy} @anchor{.wz} @anchor{.wa} 1702@anchor{.sx} @anchor{.sy} @anchor{.sz} @anchor{.sa} 1703@anchor{.kx} @anchor{.ky} @anchor{.kz} @anchor{.ka} 1704@deftypefn {MGL suffix} {(dat)} .sum 1705@deftypefnx {MGL suffix} {(dat)} .ax 1706@deftypefnx {MGL suffix} {(dat)} .ay 1707@deftypefnx {MGL suffix} {(dat)} .az 1708@deftypefnx {MGL suffix} {(dat)} .aa 1709@deftypefnx {MGL suffix} {(dat)} .wx 1710@deftypefnx {MGL suffix} {(dat)} .wy 1711@deftypefnx {MGL suffix} {(dat)} .wz 1712@deftypefnx {MGL suffix} {(dat)} .wa 1713@deftypefnx {MGL suffix} {(dat)} .sx 1714@deftypefnx {MGL suffix} {(dat)} .sy 1715@deftypefnx {MGL suffix} {(dat)} .sz 1716@deftypefnx {MGL suffix} {(dat)} .sa 1717@deftypefnx {MGL suffix} {(dat)} .kx 1718@deftypefnx {MGL suffix} {(dat)} .ky 1719@deftypefnx {MGL suffix} {(dat)} .kz 1720@deftypefnx {MGL suffix} {(dat)} .ka 1721@ifclear UDAV 1722@deftypefnx {Метод класса @code{mglDataA}} @code{mreal} Momentum (@code{char} dir, @code{mreal} &a, @code{mreal} &w) @code{const} 1723@deftypefnx {Метод класса @code{mglDataA}} @code{mreal} Momentum (@code{char} dir, @code{mreal} &m, @code{mreal} &w, @code{mreal} &s, @code{mreal} &k) @code{const} 1724@deftypefnx {Функция С} @code{mreal} mgl_data_momentum_val (@code{HCDT} dat, @code{char} dir, @code{mreal} *a, @code{mreal} *w, @code{mreal} *s, @code{mreal} *k) 1725@end ifclear 1726Возвращает нулевой момент (энергию, @math{I=\sum a_i}) и записывает первый (среднее, @math{m = \sum \xi_i a_i/I}), второй (ширину, @math{w^2 = \sum (\xi_i-m)^2 a_i/I}), третий (асимметрия, @math{s = \sum (\xi_i-m)^3 a_i/ I w^3}) и четвёртый моменты (эксцесс, @math{k = \sum (\xi_i-m)^4 a_i / 3 I w^4})). Здесь @math{\xi} -- соответствующая координата если @var{dir} равно @samp{'x'}, @samp{'y'}, @samp{'z'}. В противном случае среднее, ширина, асимметрия, эксцесс равны @math{m = \sum a_i/N}, @math{w^2 = \sum (a_i-m)^2/N} и т.д. 1727@end deftypefn 1728 1729@anchor{.fst} 1730@deftypefn {MGL suffix} {(dat)} .fst 1731@ifclear UDAV 1732@cindex Find 1733@deftypefnx {Метод класса @code{mglDataA}} @code{mreal} Find (@code{const char *}cond, @code{int} &i, @code{int} &j, @code{int} &k) @code{const} 1734@deftypefnx {Функция С} @code{mreal} mgl_data_first (@code{HCDT} dat, @code{const char *}cond, @code{int} *i, @code{int} *j, @code{int} *k) 1735@end ifclear 1736Находит положение (после заданного в @var{i}, @var{j}, @var{k}) первого не нулевого значения формулы @var{cond}. Функция возвращает найденное значение и записывает его положение в @var{i}, @var{j}, @var{k}. 1737@end deftypefn 1738 1739@anchor{.lst} 1740@deftypefn {MGL suffix} {(dat)} .lst 1741@ifclear UDAV 1742@cindex Last 1743@deftypefnx {Метод класса @code{mglDataA}} @code{mreal} Last (@code{const char *}cond, @code{int} &i, @code{int} &j, @code{int} &k) @code{const} 1744@deftypefnx {Функция С} @code{mreal} mgl_data_last (@code{HCDT} dat, @code{const char *}cond, @code{int} *i, @code{int} *j, @code{int} *k) 1745@end ifclear 1746Находит положение (перед заданного в @var{i}, @var{j}, @var{k}) последнего не нулевого значения формулы @var{cond}. Функция возвращает найденное значение и записывает его положение в @var{i}, @var{j}, @var{k}. 1747@end deftypefn 1748 1749@ifclear UDAV 1750@deftypefn {Метод класса @code{mglDataA}} @code{int} Find (@code{const char *}cond, @code{char} dir, @code{int} i=@code{0}, @code{int} j=@code{0}, @code{int} k=@code{0}) @code{const} 1751@deftypefnx {Функция С} @code{mreal} mgl_data_find (@code{HCDT} dat, @code{const char *}cond, @code{int} i, @code{int} j, @code{int} k) 1752Возвращает положение первого в направлении @var{dir} не нулевого значения формулы @var{cond}. Поиск начинается с точки @{i,j,k@}. 1753@end deftypefn 1754@cindex FindAny 1755@deftypefn {Метод класса @code{mglDataA}} @code{bool} FindAny (@code{const char *}cond) @code{const} 1756@deftypefnx {Функция С} @code{mreal} mgl_data_find_any (@code{HCDT} dat, @code{const char *}cond) 1757Определяет есть ли хоть одно значение массива, удовлетворяющее условию @var{cond}. 1758@end deftypefn 1759@end ifclear 1760 1761@anchor{.a} 1762@deftypefn {MGL suffix} {(dat)} .a 1763Возвращает первое число массива (для @code{.a} это @code{dat->a[0]}). 1764@end deftypefn 1765 1766 1767@c ------------------------------------------------------------------ 1768@external{} 1769@node Operators, Global functions, Data information, Data processing 1770@section Операторы 1771@nav{} 1772 1773@deftypefn {Команда MGL} {} copy @sc{dat} dat2 ['eq'=''] 1774@ifclear UDAV 1775@deftypefnx {Метод класса @code{mglData}} @code{void} operator= (@code{const mglDataA &}d) 1776@end ifclear 1777Копирует данные из другого экземпляра. 1778@end deftypefn 1779 1780@deftypefn {Команда MGL} {} copy dat @code{val} 1781@ifclear UDAV 1782@deftypefnx {Метод класса @code{mreal}} @code{void} operator= (@code{mreal} val) 1783@end ifclear 1784Устанавливает все значения массива равными @var{val}. 1785@end deftypefn 1786 1787@anchor{multo} 1788@deftypefn {Команда MGL} {} multo dat dat2 1789@deftypefnx {Команда MGL} {} multo dat @code{val} 1790@ifclear UDAV 1791@deftypefnx {Метод класса @code{mglData}} @code{void} operator*= (@code{const mglDataA &}d) 1792@deftypefnx {Метод класса @code{mglData}} @code{void} operator*= (@code{mreal} d) 1793@deftypefnx {Функция С} @code{void} mgl_data_mul_dat (@code{HMDT} dat, @code{HCDT} d) 1794@deftypefnx {Функция С} @code{void} mgl_data_mul_num (@code{HMDT} dat, @code{mreal} d) 1795@end ifclear 1796Поэлементно умножает на массив @var{d} или на число @var{val}. 1797@end deftypefn 1798 1799@anchor{divto} 1800@deftypefn {Команда MGL} {} divto dat dat2 1801@deftypefnx {Команда MGL} {} divto dat @code{val} 1802@ifclear UDAV 1803@deftypefnx {Метод класса @code{mglData}} @code{void} operator/= (@code{const mglDataA &}d) 1804@deftypefnx {Метод класса @code{mglData}} @code{void} operator/= (@code{mreal} d) 1805@deftypefnx {Функция С} @code{void} mgl_data_div_dat (@code{HMDT} dat, @code{HCDT} d) 1806@deftypefnx {Функция С} @code{void} mgl_data_div_num (@code{HMDT} dat, @code{mreal} d) 1807@end ifclear 1808Поэлементно делит на массив @var{d} или на число @var{val}. 1809@end deftypefn 1810 1811@anchor{addto} 1812@deftypefn {Команда MGL} {} addto dat dat2 1813@deftypefnx {Команда MGL} {} addto dat @code{val} 1814@ifclear UDAV 1815@deftypefnx {Метод класса @code{mglData}} @code{void} operator+= (@code{const mglDataA &}d) 1816@deftypefnx {Метод класса @code{mglData}} @code{void} operator+= (@code{mreal} d) 1817@deftypefnx {Функция С} @code{void} mgl_data_add_dat (@code{HMDT} dat, @code{HCDT} d) 1818@deftypefnx {Функция С} @code{void} mgl_data_add_num (@code{HMDT} dat, @code{mreal} d) 1819@end ifclear 1820Поэлементно прибавляет @var{d} или число @var{val}. 1821@end deftypefn 1822 1823@anchor{subto} 1824@deftypefn {Команда MGL} {} subto dat dat2 1825@deftypefnx {Команда MGL} {} subto dat @code{val} 1826@ifclear UDAV 1827@deftypefnx {Метод класса @code{mglData}} @code{void} operator-= (@code{const mglDataA &}d) 1828@deftypefnx {Метод класса @code{mglData}} @code{void} operator-= (@code{mreal} d) 1829@deftypefnx {Функция С} @code{void} mgl_data_sub_dat (@code{HMDT} dat, @code{HCDT} d) 1830@deftypefnx {Функция С} @code{void} mgl_data_sub_num (@code{HMDT} dat, @code{mreal} d) 1831@end ifclear 1832Поэлементно вычитает @var{d} или число @var{val}. 1833@end deftypefn 1834 1835@ifclear UDAV 1836@deftypefn {Library Function} mglData operator+ (@code{const mglDataA &}a, @code{const mglDataA &}b) 1837@deftypefnx {Library Function} mglData operator+ (@code{mreal} a, @code{const mglDataA &}b) 1838@deftypefnx {Library Function} mglData operator+ (@code{const mglDataA &}a, @code{mreal} b) 1839Возвращает поэлементную сумму данных. 1840@end deftypefn 1841 1842@deftypefn {Library Function} mglData operator- (@code{const mglDataA &}a, @code{const mglDataA &}b) 1843@deftypefnx {Library Function} mglData operator- (@code{mreal} a, @code{const mglDataA &}b) 1844@deftypefnx {Library Function} mglData operator- (@code{const mglDataA &}a, @code{mreal} b) 1845Возвращает поэлементную разность данных. 1846@end deftypefn 1847 1848@deftypefn {Library Function} mglData operator* (@code{const mglDataA &}a, @code{const mglDataA &}b) 1849@deftypefnx {Library Function} mglData operator* (@code{mreal} a, @code{const mglDataA &}b) 1850@deftypefnx {Library Function} mglData operator* (@code{const mglDataA &}a, @code{mreal} b) 1851Возвращает поэлементное произведение данных. 1852@end deftypefn 1853 1854@deftypefn {Library Function} mglData operator/ (@code{const mglDataA &}a, @code{const mglDataA &}b) 1855@deftypefnx {Library Function} mglData operator/ (@code{const mglDataA &}a, @code{mreal} b) 1856Возвращает поэлементное деление данных. 1857@end deftypefn 1858@end ifclear 1859 1860@c ------------------------------------------------------------------ 1861@external{} 1862@node Global functions, Evaluate expression, Operators, Data processing 1863@section Глобальные функции 1864@nav{} 1865 1866@ifclear UDAV 1867Эти функции не методы класса @code{mglData}, но они дают дополнительные возможности по обработке данных. Поэтому я поместил их в эту главу. 1868@end ifclear 1869 1870@anchor{transform} 1871@deftypefn {Команда MGL} {} transform @sc{dat} 'type' real imag 1872@ifclear UDAV 1873@deftypefnx {Общая функция} @code{mglData} mglTransform (@code{const mglDataA &}real, @code{const mglDataA &}imag, @code{const char *}type) 1874@deftypefnx {Функция С} @code{HMDT} mgl_transform (@code{HCDT} real, @code{HCDT} imag, @code{const char *}type) 1875@end ifclear 1876Выполняет интегральное преобразование комплексных данных @var{real}, @var{imag} в выбранном направлении и возвращает модуль результата. Порядок и тип преобразований задается строкой @var{type}: первый символ для x-направления, второй для y-направления, третий для z-направления. Возможные символы: @samp{f} -- прямое преобразование Фурье, @samp{i} -- обратное преобразование Фурье, @samp{s} -- синус преобразование, @samp{c} -- косинус преобразование, @samp{h} -- преобразование Ханкеля, @samp{n} или @samp{ } -- нет преобразования. 1877@end deftypefn 1878 1879@anchor{transforma} 1880@deftypefn {Команда MGL} {} transforma @sc{dat} 'type' ampl phase 1881@ifclear UDAV 1882@deftypefnx {Общая функция} @code{mglData} mglTransformA @code{const mglDataA &}ampl, @code{const mglDataA &}phase, @code{const char *}type) 1883@deftypefnx {Функция С} @code{HMDT} mgl_transform_a @code{HCDT} ampl, @code{HCDT} phase, @code{const char *}type) 1884@end ifclear 1885Аналогично предыдущему с заданными амплитудой @var{ampl} и фазой @var{phase} комплексных чисел. 1886@end deftypefn 1887 1888@anchor{fourier} 1889@deftypefn {Команда MGL} {} fourier reDat imDat 'dir' 1890@deftypefnx {Команда MGL} {} fourier complexDat 'dir' 1891@ifclear UDAV 1892@deftypefnx {Общая функция} @code{void} mglFourier @code{const mglDataA &}re, @code{const mglDataA &}im, @code{const char *}dir) 1893@deftypefnx {Метод класса @code{mglDataC}} @code{void} FFT (@code{const char *}dir) 1894@deftypefnx {Функция С} @code{void} mgl_data_fourier @code{HCDT} re, @code{HCDT} im, @code{const char *}dir) 1895@deftypefnx {Функция С} @code{void} mgl_datac_fft (@code{HADT} dat, @code{const char *}dir) 1896@end ifclear 1897Выполняет Фурье преобразование для комплексных данных @var{re}+i*@var{im} в направлениях @var{dir}. Результат помещается обратно в массивы @var{re} и @var{im}. Если @var{dir} содержит @samp{i}, то выполняется обратное преобразование Фурье. 1898@end deftypefn 1899 1900@anchor{stfad} 1901@deftypefn {Команда MGL} {} stfad @sc{res} real imag @code{dn} ['dir'='x'] 1902@ifclear UDAV 1903@deftypefnx {Общая функция} @code{mglData} mglSTFA (@code{const mglDataA &}real, @code{const mglDataA &}imag, @code{int} dn, @code{char} dir=@code{'x'}) 1904@deftypefnx {Функция С} @code{HMDT} mgl_data_stfa (@code{HCDT} real, @code{HCDT} imag, @code{int} dn, @code{char} dir) 1905@end ifclear 1906Выполняет оконное преобразование Фурье длиной @var{dn} для комплексных данных @var{real}, @var{imag} и возвращает модуль результата. Например, для @var{dir}=@samp{x} результат будет иметь размер @{int(nx/dn), dn, ny@} и будет равен @math{res[i,j,k]=|\sum_d^dn exp(I*j*d)*(real[i*dn+d,k]+I*imag[i*dn+d,k])|/dn}. 1907@end deftypefn 1908 1909 1910@anchor{triangulate} 1911@deftypefn {Команда MGL} {} triangulate dat xdat ydat 1912@ifclear UDAV 1913@deftypefnx {Общая функция} @code{mglData} mglTriangulation (@code{const mglDataA &}x, @code{const mglDataA &}y) 1914@deftypefnx {Функция С} @code{void} mgl_triangulation_2d (@code{HCDT} x, @code{HCDT} y) 1915@end ifclear 1916Выполняет триангуляцию Делоне для точек на плоскости и возвращает массив, пригодный для @ref{triplot} и @ref{tricont}. @sref{Making regular data} 1917@end deftypefn 1918 1919@anchor{tridmat} 1920@deftypefn {Команда MGL} {} tridmat @sc{res adat bdat cdat ddat} 'how' 1921@ifclear UDAV 1922@deftypefnx {Общая функция} @code{mglData} mglTridMat (@code{const mglDataA &}A, @code{const mglDataA &}B, @code{const mglDataA &}C, @code{const mglDataA &}D, @code{const char *}how) 1923@deftypefnx {Общая функция} @code{mglDataC} mglTridMatC (@code{const mglDataA &}A, @code{const mglDataA &}B, @code{const mglDataA &}C, @code{const mglDataA &}D, @code{const char *}how) 1924@deftypefnx {Функция С} @code{HMDT} mgl_data_tridmat (@code{HCDT} A, @code{HCDT} B, @code{HCDT} C, @code{HCDT} D, @code{const char*}how) 1925@deftypefnx {Функция С} @code{HADT} mgl_datac_tridmat (@code{HCDT} A, @code{HCDT} B, @code{HCDT} C, @code{HCDT} D, @code{const char*}how) 1926@end ifclear 1927Возвращает решение трехдиагональной системы уравнений @var{A}[i]*x[i-1]+@var{B}[i]*x[i]+@var{C}[i]*x[i+1]=@var{D}[i]. Строка @var{how} может содержать: 1928@itemize @bullet 1929@item 1930@samp{xyz} для решения вдоль x-,y-,z-направлений; 1931@item 1932@samp{h} для решения вдоль диагонали на плоскости x-y (требует квадратную матрицу); 1933@item 1934@samp{c} для использования периодических граничных условий; 1935@item 1936@samp{d} для расчета диффракции/диффузии (т.е. для использования -@var{A}[i]*@var{D}[i-1]+(2-@var{B}[i])*@var{D}[i]-@var{C}[i]*@var{D}[i+1] в правой частиц вместо @var{D}[i]). 1937@end itemize 1938Размеры массивов @var{A}, @var{B}, @var{C} должны быть одинаковы. Также их размерности должны совпадать со всеми или с "младшими" размерностями массива @var{D}. @sref{PDE solving hints} 1939@end deftypefn 1940 1941@anchor{pde} 1942@deftypefn {Команда MGL} {} pde @sc{res} 'ham' ini_re ini_im [@code{dz=0.1 k0=100}] 1943@ifclear UDAV 1944@deftypefnx {Общая функция} @code{mglData} mglPDE (@code{HMGL} gr, @code{const char *}ham, @code{const mglDataA &}ini_re, @code{const mglDataA &}ini_im, @code{mreal} dz=@code{0.1}, @code{mreal} k0=@code{100}, @code{const char *}opt=@code{""}) 1945@deftypefnx {Общая функция} @code{mglDataC} mglPDEc (@code{HMGL} gr, @code{const char *}ham, @code{const mglDataA &}ini_re, @code{const mglDataA &}ini_im, @code{mreal} dz=@code{0.1}, @code{mreal} k0=@code{100}, @code{const char *}opt=@code{""}) 1946@deftypefnx {Функция С} @code{HMDT} mgl_pde_solve (@code{HMGL} gr, @code{const char *}ham, @code{HCDT} ini_re, @code{HCDT} ini_im, @code{mreal} dz, @code{mreal} k0, @code{const char *}opt) 1947@deftypefnx {Функция С} @code{HADT} mgl_pde_solve_c (@code{HMGL} gr, @code{const char *}ham, @code{HCDT} ini_re, @code{HCDT} ini_im, @code{mreal} dz, @code{mreal} k0, @code{const char *}opt) 1948@end ifclear 1949Решает уравнение в частных производных du/dz = i*k0*@var{ham}(p,q,x,y,z,|u|)[u], где p=-i/k0*d/dx, q=-i/k0*d/dy -- псевдо-дифференциальные операторы. Параметры @var{ini_re}, @var{ini_im} задают начальное распределение поля. Координаты в уравнении и в решении полагаются в диапазоне осей координат. Замечу, что внутри этот диапазон увеличивается в 3/2 раза для уменьшения отражения от границ расчетного интервала. Параметр @var{dz} задает шаг по эволюционной координате z. В данный момент использован упрощенный алгоритм, когда все ``смешанные'' члена (типа @samp{x*p}->x*d/dx) исключаются. Например, в 2D случае это функции типа @math{ham = f(p,z) + g(x,z,u)}. При этом допускаются коммутирующие комбинации (типа @samp{x*q}->x*d/dy). Переменная @samp{u} используется для обозначения амплитуды поля |u|. Это позволяет решать нелинейные задачи -- например, нелинейное уравнение Шредингера @code{ham='p^2+q^2-u^2'}. Также можно указать мнимую часть для поглощения (типа @code{ham = 'p^2+i*x*(x>0)'}). См. также @ref{apde}, @ref{qo2d}, @ref{qo3d}. @sref{PDE solving hints} 1950@end deftypefn 1951 1952@anchor{apde} 1953@deftypefn {Команда MGL} {} apde @sc{res} 'ham' ini_re ini_im [@code{dz=0.1 k0=100}] 1954@ifclear UDAV 1955@deftypefnx {Общая функция} @code{mglData} mglAPDE (@code{HMGL} gr, @code{const char *}ham, @code{const mglDataA &}ini_re, @code{const mglDataA &}ini_im, @code{mreal} dz=@code{0.1}, @code{mreal} k0=@code{100}, @code{const char *}opt=@code{""}) 1956@deftypefnx {Общая функция} @code{mglDataC} mglAPDEc (@code{HMGL} gr, @code{const char *}ham, @code{const mglDataA &}ini_re, @code{const mglDataA &}ini_im, @code{mreal} dz=@code{0.1}, @code{mreal} k0=@code{100}, @code{const char *}opt=@code{""}) 1957@deftypefnx {Функция С} @code{HMDT} mgl_pde_solve_adv (@code{HMGL} gr, @code{const char *}ham, @code{HCDT} ini_re, @code{HCDT} ini_im, @code{mreal} dz, @code{mreal} k0, @code{const char *}opt) 1958@deftypefnx {Функция С} @code{HADT} mgl_pde_solve_adv_c (@code{HMGL} gr, @code{const char *}ham, @code{HCDT} ini_re, @code{HCDT} ini_im, @code{mreal} dz, @code{mreal} k0, @code{const char *}opt) 1959@end ifclear 1960Решает уравнение в частных производных du/dz = i*k0*@var{ham}(p,q,x,y,z,|u|)[u], где p=-i/k0*d/dx, q=-i/k0*d/dy -- псевдо-дифференциальные операторы. Параметры @var{ini_re}, @var{ini_im} задают начальное распределение поля. Координаты в уравнении и в решении полагаются в диапазоне осей координат. Замечу, что внутри этот диапазон увеличивается в 3/2 раза для уменьшения отражения от границ расчетного интервала. Параметр @var{dz} задает шаг по эволюционной координате z. Используется достаточно сложный и медленный алгоритм, способный учесть одновременное влияние пространственной дисперсии и неоднородности среды [см. А.А. Балакин, Е.Д. Господчиков, А.Г. Шалашов, Письма ЖЭТФ 104, 701 (2016)]. Переменная @samp{u} используется для обозначения амплитуды поля |u|. Это позволяет решать нелинейные задачи -- например, нелинейное уравнение Шредингера @code{ham='p^2+q^2-u^2'}. Также можно указать мнимую часть для поглощения (типа @code{ham = 'p^2+i*x*(x>0)'}). См. также @ref{apde}. @sref{PDE solving hints} 1961@end deftypefn 1962 1963@anchor{ray} 1964@deftypefn {Команда MGL} {} ray @sc{res} 'ham' @code{x0 y0 z0 p0 q0 v0 [dt=0.1 tmax=10]} 1965@ifclear UDAV 1966@deftypefnx {Общая функция} @code{mglData} mglRay (@code{const char *}ham, @code{mglPoint} r0, @code{mglPoint} p0, @code{mreal} dt=@code{0.1}, @code{mreal} tmax=@code{10}) 1967@deftypefnx {Функция С} @code{HMDT} mgl_ray_trace (@code{const char *}ham, @code{mreal} x0, @code{mreal} y0, @code{mreal} z0, @code{mreal} px, @code{mreal} py, @code{mreal} pz, @code{mreal} dt, @code{mreal} tmax) 1968@end ifclear 1969Решает систему геометрооптических уравнений d@emph{r}/dt = d @var{ham}/d@emph{p}, d@emph{p}/dt = -d @var{ham}/d@emph{r}. Это гамильтоновы уравнения для траектории частицы в 3D случае. Гамильтониан @var{ham} может зависеть от координат @samp{x}, @samp{y}, @samp{z}, импульсов @samp{p}=px, @samp{q}=py, @samp{v}=pz и времени @samp{t}: @math{ham = H(x,y,z,p,q,v,t)}. Начальная точка (при @code{t=0}) задается переменными @{@var{x0}, @var{y0}, @var{z0}, @var{p0}, @var{q0}, @var{v0}@}. Параметры @var{dt} и @var{tmax} задают шаг и максимальное время интегрирования. Результат -- массив @{x,y,z,p,q,v,t@} с размером @{7 * int(@var{tmax}/@var{dt}+1) @}. 1970@end deftypefn 1971 1972@anchor{ode} 1973@deftypefn {Команда MGL} {} ode @sc{res} 'df' 'var' ini [@code{dt=0.1 tmax=10}] 1974@ifclear UDAV 1975@deftypefnx {Общая функция} @code{mglData} mglODE (@code{const char *}df, @code{const char *}var, @code{const mglDataA &}ini, @code{mreal} dt=@code{0.1}, @code{mreal} tmax=@code{10}) 1976@deftypefnx {Общая функция} @code{mglDataC} mglODEc (@code{const char *}df, @code{const char *}var, @code{const mglDataA &}ini, @code{mreal} dt=@code{0.1}, @code{mreal} tmax=@code{10}) 1977@deftypefnx {Функция С} @code{HMDT} mgl_ode_solve_str (@code{const char *}df, @code{const char *}var, @code{HCDT} ini, @code{mreal} dt, @code{mreal} tmax) 1978@deftypefnx {Функция С} @code{HADT} mgl_ode_solve_str_c (@code{const char *}df, @code{const char *}var, @code{HCDT} ini, @code{mreal} dt, @code{mreal} tmax) 1979@deftypefnx {Функция С} @code{HMDT} mgl_ode_solve (@code{void (*}df@code{)(const mreal *x, mreal *dx, void *par)}, @code{int} n, @code{const mreal *}ini, @code{mreal} dt, @code{mreal} tmax) 1980@deftypefnx {Функция С} @code{HMDT} mgl_ode_solve_ex (@code{void (*}df@code{)(const mreal *x, mreal *dx, void *par)}, @code{int} n, @code{const mreal *}ini, @code{mreal} dt, @code{mreal} tmax, @code{void (*}bord@code{)(mreal *x, const mreal *xprev, void *par)}) 1981@end ifclear 1982Решает систему обыкновенных дифференциальных уравнений dx/dt = df(x). Функции @var{df} могут быть заданны строкой с разделенными ';' формулами (аргумент @var{var} задает символы для переменных x[i]) или указателем на функцию, которая заполняет @code{dx} по заданным значениям @code{x}. Параметры @var{ini}, @var{dt}, @var{tmax} задают начальные значения, шаг и максимальное время интегрирования. Функция обрывает расчет при появлении значений @code{NAN} или @code{INF}. Результат -- массив размером @{@var{n} * @var{Nt}@}, где @var{Nt} <= int(@var{tmax}/@var{dt}+1). 1983 1984Если @var{dt}*@var{tmax}<0, то включается регуляризация, при которой уравнение заменяется на dx/ds = df(x)/max(|df(x)|) для более аккуратного прохождения областей резкого изменения df и более быстрого расчета в области малых df. Здесь s -- новое "время". При этом реальное время определяется уравнением dt/ds=max(|df(x)|). Поэтому для вывода реального времени его следует явно добавить в уравнение, например @samp{ode res 'y;-sin(x);1' 'xyt' [3,0] 0.3 -100}. Оно также сохранит точность вблизи стационарных точек (т.е. при малых df в периодическом движении). 1985@end deftypefn 1986 1987 1988@deftypefn {Команда MGL} {} ode @sc{res} 'df' 'var' 'brd' ini [@code{dt=0.1 tmax=10}] 1989@ifclear UDAV 1990@deftypefnx {Общая функция} @code{mglData} mglODEs (@code{const char *}df, @code{const char *}var, @code{char} brd, @code{const mglDataA &}ini, @code{mreal} dt=@code{0.1}, @code{mreal} tmax=@code{10}) 1991@deftypefnx {Общая функция} @code{mglDataC} mglODEcs (@code{const char *}df, @code{const char *}var, @code{char} brd, @code{const mglDataA &}ini, @code{mreal} dt=@code{0.1}, @code{mreal} tmax=@code{10}) 1992@deftypefnx {Функция С} @code{HMDT} mgl_ode_solve_set (@code{const char *}df, @code{const char *}var, @code{char} brd, @code{HCDT} ini, @code{mreal} dt, @code{mreal} tmax) 1993@deftypefnx {Функция С} @code{HADT} mgl_ode_solve_set_c (@code{const char *}df, @code{const char *}var, @code{char} brd, @code{HCDT} ini, @code{mreal} dt, @code{mreal} tmax) 1994@end ifclear 1995Решает разностную аппроксимацию уравнений в частных производных как систему обыкновенных дифференциальных уравнений dx/dt = df(x,j). Функции @var{df} могут быть заданны строкой с разделенными ';' формулами, зависящими от индекса @var{j} и текущего времени @samp{t}. Аргумент @var{var} задает символы для переменных x[i]. Параметр @var{brd} задает тип граничных условий по @var{j}: @samp{0} или @samp{z} -- нулевые, @samp{1} или @samp{c} -- постоянные, @samp{2} или @samp{l} -- линейные (ноль лапласиана), @samp{3} или @samp{s} -- квадратичные, @samp{4} или @samp{e} -- экспоненциальные, @samp{5} или @samp{g} -- гауссовы. Последние два типа условий применимы только в случае комплексных переменных. Параметры @var{ini}, @var{dt}, @var{tmax} задают начальные значения, шаг и максимальное время интегрирования. Функция обрывает расчет при появлении значений @code{NAN} или @code{INF}. Результат -- массив размером @{@var{n} * @var{Nt}@}, где @var{Nt} <= int(@var{tmax}/@var{dt}+1). Например, разностная аппроксимация уравнения диффузии с нулевыми граничными условиями находится вызовом: @samp{ode res 'u(j+1)-2*u(j)+u(j-1)' 'u' '0' u0}, где @samp{u0} -- массив начальных значений. 1996 1997Если @var{dt}*@var{tmax}<0, то включается регуляризация, при которой уравнение заменяется на dx/ds = df(x)/max(|df(x)|) для более аккуратного прохождения областей резкого изменения df и более быстрого расчета в области малых df. Здесь s -- новое "время". При этом реальное время определяется уравнением dt/ds=max(|df(x)|). Поэтому для вывода реального времени его следует явно добавить в уравнение, например @samp{ode res 'y;-sin(x);1' 'xyt' [3,0] 0.3 -100}. Оно также сохранит точность вблизи стационарных точек (т.е. при малых df в периодическом движении). 1998@end deftypefn 1999 2000 2001 2002@anchor{qo2d} 2003@deftypefn {Команда MGL} {} qo2d @sc{res} 'ham' ini_re ini_im ray [@code{r=1 k0=100} xx yy] 2004@ifclear UDAV 2005@deftypefnx {Общая функция} @code{mglData} mglQO2d (@code{const char *}ham, @code{const mglDataA &}ini_re, @code{const mglDataA &}ini_im, @code{const mglDataA &}ray, @code{mreal} r=@code{1}, @code{mreal} k0=@code{100}, @code{mglData *}xx=@code{0}, @code{mglData *}yy=@code{0}) 2006@deftypefnx {Общая функция} @code{mglData} mglQO2d (@code{const char *}ham, @code{const mglDataA &}ini_re, @code{const mglDataA &}ini_im, @code{const mglDataA &}ray, @code{mglData &}xx, @code{mglData &}yy, @code{mreal} r=@code{1}, @code{mreal} k0=@code{100}) 2007@deftypefnx {Общая функция} @code{mglDataC} mglQO2dc (@code{const char *}ham, @code{const mglDataA &}ini_re, @code{const mglDataA &}ini_im, @code{const mglDataA &}ray, @code{mreal} r=@code{1}, @code{mreal} k0=@code{100}) 2008@deftypefnx {Общая функция} @code{mglDataC} mglQO2dc (@code{const char *}ham, @code{const mglDataA &}ini_re, @code{const mglDataA &}ini_im, @code{const mglDataA &}ray, @code{mglData &}xx, @code{mglData &}yy, @code{mreal} r=@code{1}, @code{mreal} k0=@code{100}) 2009@deftypefnx {Функция С} @code{HMDT} mgl_qo2d_solve (@code{const char *}ham, @code{HCDT} ini_re, @code{HCDT} ini_im, @code{HCDT} ray, @code{mreal} r, @code{mreal} k0, @code{HMDT} xx, @code{HMDT} yy) 2010@deftypefnx {Функция С} @code{HADT} mgl_qo2d_solve_c (@code{const char *}ham, @code{HCDT} ini_re, @code{HCDT} ini_im, @code{HCDT} ray, @code{mreal} r, @code{mreal} k0, @code{HMDT} xx, @code{HMDT} yy) 2011@deftypefnx {Функция С} @code{HMDT} mgl_qo2d_func (@code{dual (*}ham@code{)(mreal u, mreal x, mreal y, mreal px, mreal py, void *par)}, @code{HCDT} ini_re, @code{HCDT} ini_im, @code{HCDT} ray, @code{mreal} r, @code{mreal} k0, @code{HMDT} xx, @code{HMDT} yy) 2012@deftypefnx {Функция С} @code{HADT} mgl_qo2d_func_c (@code{dual (*}ham@code{)(mreal u, mreal x, mreal y, mreal px, mreal py, void *par)}, @code{HCDT} ini_re, @code{HCDT} ini_im, @code{HCDT} ray, @code{mreal} r, @code{mreal} k0, @code{HMDT} xx, @code{HMDT} yy) 2013@end ifclear 2014Решает уравнение в частных производных du/dt = i*k0*@var{ham}(p,q,x,y,|u|)[u] в сопровождающей системе координат, где p=-i/k0*d/dx, q=-i/k0*d/dy -- псевдо-дифференциальные операторы. Параметры @var{ini_re}, @var{ini_im} задают начальное распределение поля. Параметр @var{ray} задает опорный луч для сопровождающей системы координат. Можно использовать луч найденный с помощью @ref{ray}. Опорный луч должен быть достаточно гладкий, чтобы система координат была однозначной и для исключения ошибок интегрирования. Если массивы @var{xx} и @var{yy} указаны, то в них записываются декартовы координаты для каждой точки найденного решения. См. также @ref{pde}, @ref{qo3d}. @sref{PDE solving hints} 2015@end deftypefn 2016 2017@anchor{qo3d} 2018@deftypefn {Команда MGL} {} qo3d @sc{res} 'ham' ini_re ini_im ray [@code{r=1 k0=100} xx yy zz] 2019@ifclear UDAV 2020@deftypefnx {Общая функция} @code{mglData} mglQO3d (@code{const char *}ham, @code{const mglDataA &}ini_re, @code{const mglDataA &}ini_im, @code{const mglDataA &}ray, @code{mreal} r=@code{1}, @code{mreal} k0=@code{100}) 2021@deftypefnx {Общая функция} @code{mglData} mglQO3d (@code{const char *}ham, @code{const mglDataA &}ini_re, @code{const mglDataA &}ini_im, @code{const mglDataA &}ray, @code{mglData &}xx, @code{mglData &}yy, @code{mglData &}zz, @code{mreal} r=@code{1}, @code{mreal} k0=@code{100}) 2022@deftypefnx {Общая функция} @code{mglDataC} mglQO3dc (@code{const char *}ham, @code{const mglDataA &}ini_re, @code{const mglDataA &}ini_im, @code{const mglDataA &}ray, @code{mreal} r=@code{1}, @code{mreal} k0=@code{100}) 2023@deftypefnx {Общая функция} @code{mglDataC} mglQO3dc (@code{const char *}ham, @code{const mglDataA &}ini_re, @code{const mglDataA &}ini_im, @code{const mglDataA &}ray, @code{mglData &}xx, @code{mglData &}yy, @code{mglData &}zz, @code{mreal} r=@code{1}, @code{mreal} k0=@code{100}) 2024@deftypefnx {Функция С} @code{HMDT} mgl_qo3d_solve (@code{const char *}ham, @code{HCDT} ini_re, @code{HCDT} ini_im, @code{HCDT} ray, @code{mreal} r, @code{mreal} k0, @code{HMDT} xx, @code{HMDT} yy, @code{HMDT} zz) 2025@deftypefnx {Функция С} @code{HADT} mgl_qo3d_solve_c (@code{const char *}ham, @code{HCDT} ini_re, @code{HCDT} ini_im, @code{HCDT} ray, @code{mreal} r, @code{mreal} k0, @code{HMDT} xx, @code{HMDT} yy, @code{HMDT} zz) 2026@deftypefnx {Функция С} @code{HMDT} mgl_qo3d_func (@code{dual (*}ham@code{)(mreal u, mreal x, mreal y, mreal z, mreal px, mreal py, mreal pz, void *par)}, @code{HCDT} ini_re, @code{HCDT} ini_im, @code{HCDT} ray, @code{mreal} r, @code{mreal} k0, @code{HMDT} xx, @code{HMDT} yy, @code{HMDT} zz) 2027@deftypefnx {Функция С} @code{HADT} mgl_qo3d_func_c (@code{dual (*}ham@code{)(mreal u, mreal x, mreal y, mreal z, mreal px, mreal py, mreal pz, void *par)}, @code{HCDT} ini_re, @code{HCDT} ini_im, @code{HCDT} ray, @code{mreal} r, @code{mreal} k0, @code{HMDT} xx, @code{HMDT} yy, @code{HMDT} zz) 2028@end ifclear 2029Решает уравнение в частных производных du/dt = i*k0*@var{ham}(p,q,v,x,y,z,|u|)[u] в сопровождающей системе координат, где p=-i/k0*d/dx, q=-i/k0*d/dy, v=-i/k0*d/dz -- псевдо-дифференциальные операторы. Параметры @var{ini_re}, @var{ini_im} задают начальное распределение поля. Параметр @var{ray} задает опорный луч для сопровождающей системы координат. Можно использовать луч найденный с помощью @ref{ray}. Опорный луч должен быть достаточно гладкий, чтобы система координат была однозначной и для исключения ошибок интегрирования. Если массивы @var{xx}, @var{yy} и @var{zz} указаны, то в них записываются декартовы координаты для каждой точки найденного решения. См. также @ref{pde}, @ref{qo2d}. 2030@end deftypefn 2031 2032@anchor{jacobian} 2033@deftypefn {Команда MGL} {} jacobian @sc{res} xdat ydat [zdat] 2034@ifclear UDAV 2035@deftypefnx {Общая функция} @code{mglData} mglJacobian (@code{const mglDataA &}x, @code{const mglDataA &}y) 2036@deftypefnx {Общая функция} @code{mglData} mglJacobian (@code{const mglDataA &}x, @code{const mglDataA &}y, @code{const mglDataA &}z) 2037@deftypefnx {Функция С} @code{HMDT} mgl_jacobian_2d (@code{HCDT} x, @code{HCDT} y) 2038@deftypefnx {Функция С} @code{HMDT} mgl_jacobian_3d (@code{HCDT} x, @code{HCDT} y, @code{HCDT} z) 2039@end ifclear 2040Вычисляет якобиан преобразования @{i,j,k@} в @{@var{x},@var{y},@var{z}@}, где координаты @{i,j,k@} полагаются нормированными в интервал [0,1]. Якобиан находится по формуле det||@math{dr_\alpha/d\xi_\beta}||, где @math{r}=@{@var{x},@var{y},@var{z}@} и @math{\xi}=@{i,j,k@}. Все размерности всех массивов должны быть одинаковы. Данные должны быть трехмерными если указаны все 3 массива @{@var{x},@var{y},@var{z}@} или двумерными если только 2 массива @{@var{x},@var{y}@}. 2041@end deftypefn 2042 2043@anchor{triangulation} 2044@deftypefn {Команда MGL} {} triangulation @sc{res} xdat ydat [zdat] 2045@c @deftypefn {Команда MGL} {} triangulation @sc{res} xdat ydat [zdat] 2046@ifclear UDAV 2047@deftypefnx {Общая функция} @code{mglData} mglTriangulation (@code{const mglDataA &}x, @code{const mglDataA &}y) 2048@deftypefnx {Общая функция} @code{mglData} mglTriangulation (@code{const mglDataA &}x, @code{const mglDataA &}y, @code{const mglDataA &}z) 2049@deftypefnx {Функция С} @code{HMDT} mgl_triangulation_2d (@code{HCDT} x, @code{HCDT} y) 2050@deftypefnx {Функция С} @code{HMDT} mgl_triangulation_3d (@code{HCDT} x, @code{HCDT} y, @code{HCDT} z) 2051@end ifclear 2052Выполняет триангуляцию для произвольно расположенных точек с координатами @{@var{x},@var{y},@var{z}@} (т.е. находит треугольники, соединяющие точки). Первая размерность всех массивов должна быть одинакова @code{x.nx=y.nx=z.nx}. Получившийся массив можно использовать в @ref{triplot} или @ref{tricont} для визуализации реконструированной поверхности. @sref{Making regular data} 2053@end deftypefn 2054 2055 2056@ifclear UDAV 2057 2058@deftypefn {Общая функция} @code{mglData} mglGSplineInit (@code{const mglDataA &}x, @code{const mglDataA &}y) 2059@deftypefnx {Общая функция} @code{mglDataC} mglGSplineCInit (@code{const mglDataA &}x, @code{const mglDataA &}y) 2060@deftypefnx {Функция С} @code{HMDT} mgl_gspline_init (@code{HCDT} x, @code{HCDT} y) 2061@deftypefnx {Функция С} @code{HADT} mgl_gsplinec_init (@code{HCDT} x, @code{HCDT} y) 2062Подготавливает коэффициенты для глобального кубического сплайна. 2063@end deftypefn 2064 2065@deftypefn {Общая функция} @code{mreal} mglGSpline (@code{const mglDataA &}coef, @code{mreal} dx, @code{mreal *}d1=@code{0}, @code{mreal *}d2=@code{0}) 2066@deftypefnx {Общая функция} @code{dual} mglGSplineC (@code{const mglDataA &}coef, @code{mreal} dx, @code{dual *}d1=@code{0}, @code{dual *}d2=@code{0}) 2067@deftypefnx {Функция С} @code{mreal} mgl_gspline (@code{HCDT} coef, @code{mreal} dx, @code{mreal *}d1, @code{mreal *}d2) 2068@deftypefnx {Функция С} @code{dual} mgl_gsplinec (@code{HCDT} coef, @code{mreal} dx, @code{dual *}d1, @code{dual *}d2) 2069Вычисляет глобальный кубический сплайн (а также 1ую и 2ую производные @var{d1}, @var{d2} если они не @code{NULL}), используя коэффициенты @var{coef} в точке @var{dx}+@var{x0} (здесь @var{x0} -- 1ый элемент массива @var{x} в функции @code{mglGSpline*Init()}). 2070@end deftypefn 2071 2072@end ifclear 2073 2074@anchor{ifs2d} 2075@deftypefn {Команда MGL} {} ifs2d @sc{res} dat @code{num} [@code{skip=20}] 2076@ifclear UDAV 2077@deftypefnx {Общая функция} @code{mglData} mglIFS2d (@code{const mglDataA &}dat, @code{long} num, @code{long} skip=@code{20}) 2078@deftypefnx {Функция С} @code{HMDT} mgl_data_ifs_2d (@code{HCDT} dat, @code{long} num, @code{long} skip) 2079@end ifclear 2080Находит @var{num} точек @{x[i]=res[0,i], y[i]=res[1,i]@} фрактала с использованием итерационной системы функций (IFS). Матрица @var{dat} используется для генерации в соответствии с формулами 2081@verbatim 2082x[i+1] = dat[0,i]*x[i] + dat[1,i]*y[i] + dat[4,i]; 2083y[i+1] = dat[2,i]*x[i] + dat[3,i]*y[i] + dat[5,i]; 2084@end verbatim 2085Значение @code{dat[6,i]} -- весовой коэффициент для i-ой строки матрицы @var{dat}. Первые @var{skip} итераций будут опущены. Массив @var{dat} должен иметь размер по x больше или равный 7. См. также @ref{ifs3d}, @ref{flame2d}. @sref{ifs2d sample} 2086@end deftypefn 2087 2088@anchor{ifs3d} 2089@deftypefn {Команда MGL} {} ifs3d @sc{res} dat @code{num} [@code{skip=20}] 2090@ifclear UDAV 2091@deftypefnx {Общая функция} @code{mglData} mglIFS3d (@code{const mglDataA &}dat, @code{long} num, @code{long} skip=@code{20}) 2092@deftypefnx {Функция С} @code{HMDT} mgl_data_ifs_3d (@code{HCDT} dat, @code{long} num, @code{long} skip) 2093@end ifclear 2094Находит @var{num} точек @{x[i]=res[0,i], y[i]=res[1,i], z[i]=res[2,i]@} фрактала с использованием итерационной системы функций (IFS). Матрица @var{dat} используется для генерации в соответствии с формулами 2095@verbatim 2096x[i+1] = dat[0,i]*x[i] + dat[1,i]*y[i] + dat[2,i]*z[i] + dat[9,i]; 2097y[i+1] = dat[3,i]*x[i] + dat[4,i]*y[i] + dat[5,i]*z[i] + dat[10,i]; 2098z[i+1] = dat[6,i]*x[i] + dat[7,i]*y[i] + dat[8,i]*z[i] + dat[11,i]; 2099@end verbatim 2100Значение @code{dat[12,i]} -- весовой коэффициент для i-ой строки матрицы @var{dat}. Первые @var{skip} итераций будут опущены. Массив @var{dat} должен иметь размер по x больше или равный 13. См. также @ref{ifs2d}. @sref{ifs3d sample} 2101@end deftypefn 2102 2103@anchor{ifsfile} 2104@deftypefn {Команда MGL} {} ifsfile @sc{res} 'fname' 'name' @code{num} [@code{skip=20}] 2105@ifclear UDAV 2106@deftypefnx {Общая функция} @code{mglData} mglIFSfile (@code{const char *}fname, @code{const char *}name, @code{long} num, @code{long} skip=@code{20}) 2107@deftypefnx {Функция С} @code{HMDT} mgl_data_ifs_file (@code{const char *}fname, @code{const char *}name, @code{long} num, @code{long} skip) 2108@end ifclear 2109Считывает параметры фрактала @var{name} из файла @var{fname} и находит @var{num} точек для него. Первые @var{skip} итераций будут опущены. См. также @ref{ifs2d}, @ref{ifs3d}. 2110 2111Файл IFS может содержать несколько записей. Каждая запись содержит имя фрактала (@samp{binary} в примере ниже) и тело в фигурных скобках @{@} с параметрами фрактала. Символ @samp{;} начинает комментарий. Если имя содержит @samp{(3D)} или @samp{(3d)}, то определен 3d IFS фрактал. Пример содержит два фрактала: @samp{binary} -- обычный 2d фрактал, и @samp{3dfern (3D)} -- 3d фрактал. См. также @ref{ifs2d}, @ref{ifs3d}. 2112 2113@verbatim 2114 binary 2115 { ; comment allowed here 2116 ; and here 2117 .5 .0 .0 .5 -2.563477 -0.000003 .333333 ; also comment allowed here 2118 .5 .0 .0 .5 2.436544 -0.000003 .333333 2119 .0 -.5 .5 .0 4.873085 7.563492 .333333 2120 } 2121 2122 3dfern (3D) { 2123 .00 .00 0 .0 .18 .0 0 0.0 0.00 0 0.0 0 .01 2124 .85 .00 0 .0 .85 .1 0 -0.1 0.85 0 1.6 0 .85 2125 .20 -.20 0 .2 .20 .0 0 0.0 0.30 0 0.8 0 .07 2126 -.20 .20 0 .2 .20 .0 0 0.0 0.30 0 0.8 0 .07 2127 } 2128@end verbatim 2129@end deftypefn 2130 2131@anchor{flame2d} 2132@deftypefn {Команда MGL} {} flame2d @sc{res} dat func @code{num} [@code{skip=20}] 2133@ifclear UDAV 2134@deftypefnx {Общая функция} @code{mglData} mglFlame2d (@code{const mglDataA &}dat, @code{const mglDataA &}func, @code{long} num, @code{long} skip=@code{20}) 2135@deftypefnx {Функция С} @code{HMDT} mgl_data_flame_2d (@code{HCDT} dat, @code{HCDT} func, @code{long} num, @code{long} skip) 2136@end ifclear 2137Находит @var{num} точек @{x[i]=res[0,i], y[i]=res[1,i]@} фрактала с использованием итерационной системы функций (IFS). Массив @var{func} задает идентификатор функции (@var{func}[0,i,j]), ее вес (@var{func}[0,i,j]) и аргументы (@var{func}[2 ... 5,i,j]). Матрица @var{dat} используется для преобразования координат для аргументов функции. Результирующее преобразование имеет вид: 2138@verbatim 2139xx = dat[0,i]*x[j] + dat[1,j]*y[i] + dat[4,j]; 2140yy = dat[2,i]*x[j] + dat[3,j]*y[i] + dat[5,j]; 2141x[j+1] = sum_i @var{func}[1,i,j]*@var{func}[0,i,j]_x(xx, yy; @var{func}[2,i,j],...,@var{func}[5,i,j]); 2142y[j+1] = sum_i @var{func}[1,i,j]*@var{func}[0,i,j]_y(xx, yy; @var{func}[2,i,j],...,@var{func}[5,i,j]); 2143@end verbatim 2144Значение @code{dat[6,i]} -- весовой коэффициент для i-ой строки матрицы @var{dat}. Первые @var{skip} итераций будут опущены. Массив @var{dat} должен иметь размер по x больше или равный 7. 2145Доступные идентификаторы функций: @code{mglFlame2d_linear=0, mglFlame2d_sinusoidal, mglFlame2d_spherical, mglFlame2d_swirl, mglFlame2d_horseshoe, 2146 mglFlame2d_polar, mglFlame2d_handkerchief,mglFlame2d_heart, mglFlame2d_disc, mglFlame2d_spiral, 2147 mglFlame2d_hyperbolic, mglFlame2d_diamond, mglFlame2d_ex, mglFlame2d_julia, mglFlame2d_bent, 2148 mglFlame2d_waves, mglFlame2d_fisheye, mglFlame2d_popcorn, mglFlame2d_exponential, mglFlame2d_power, 2149 mglFlame2d_cosine, mglFlame2d_rings, mglFlame2d_fan, mglFlame2d_blob, mglFlame2d_pdj, 2150 mglFlame2d_fan2, mglFlame2d_rings2, mglFlame2d_eyefish, mglFlame2d_bubble, mglFlame2d_cylinder, 2151 mglFlame2d_perspective, mglFlame2d_noise, mglFlame2d_juliaN, mglFlame2d_juliaScope, mglFlame2d_blur, 2152 mglFlame2d_gaussian, mglFlame2d_radialBlur, mglFlame2d_pie, mglFlame2d_ngon, mglFlame2d_curl, 2153 mglFlame2d_rectangles, mglFlame2d_arch, mglFlame2d_tangent, mglFlame2d_square, mglFlame2d_blade, 2154 mglFlame2d_secant, mglFlame2d_rays, mglFlame2d_twintrian, mglFlame2d_cross, mglFlame2d_disc2, 2155 mglFlame2d_supershape, mglFlame2d_flower, mglFlame2d_conic, mglFlame2d_parabola, mglFlame2d_bent2, 2156 mglFlame2d_bipolar, mglFlame2d_boarders, mglFlame2d_butterfly, mglFlame2d_cell, mglFlame2d_cpow, 2157 mglFlame2d_curve, mglFlame2d_edisc, mglFlame2d_elliptic, mglFlame2d_escher, mglFlame2d_foci, 2158 mglFlame2d_lazySusan, mglFlame2d_loonie, mglFlame2d_preBlur, mglFlame2d_modulus, mglFlame2d_oscope, 2159 mglFlame2d_polar2, mglFlame2d_popcorn2, mglFlame2d_scry, mglFlame2d_separation, mglFlame2d_split, 2160 mglFlame2d_splits, mglFlame2d_stripes, mglFlame2d_wedge, mglFlame2d_wedgeJulia, mglFlame2d_wedgeSph, 2161 mglFlame2d_whorl, mglFlame2d_waves2, mglFlame2d_exp, mglFlame2d_log, mglFlame2d_sin, 2162 mglFlame2d_cos, mglFlame2d_tan, mglFlame2d_sec, mglFlame2d_csc, mglFlame2d_cot, 2163 mglFlame2d_sinh, mglFlame2d_cosh, mglFlame2d_tanh, mglFlame2d_sech, mglFlame2d_csch, 2164 mglFlame2d_coth, mglFlame2d_auger, mglFlame2d_flux.} 2165Значение @code{dat[6,i]} -- весовой коэффициент для i-ой строки матрицы @var{dat}. Первые @var{skip} итераций будут опущены. Размеры массивов должны удовлетворять требованиям: @var{dat}.nx>=7, @var{func}.nx>=2 и @var{func}.nz=@var{dat}.ny. См. также @ref{ifs2d}, @ref{ifs3d}. @sref{flame2d sample} 2166@end deftypefn 2167 2168 2169 2170@c ------------------------------------------------------------------ 2171@external{} 2172@node Evaluate expression, Special data classes, Global functions, Data processing 2173@section Вычисление выражений 2174@nav{} 2175 2176@ifset UDAV 2177В MGL скриптах в качестве аргументов команд можно использовать произвольные формулы от существующих массивов данных и констант. Есть только 2 ограничения: формула не должна содержать пробелов (чтобы распознаваться как один аргумент), формула не может быть аргументом, который может быть пересоздан при выполнении скрипта. 2178@end ifset 2179 2180@ifclear UDAV 2181В MathGL есть специальные классы @code{mglExpr} и @code{mglExprC} для вычисления формул заданных строкой для действительных и комплексных чисел соответственно. Классы определены в @code{#include <mgl2/data.h>} и @code{#include <mgl2/datac.h>} соответственно. При создании класса происходит разбор формулы в древовидную структуру. А при вычислении только выполняется достаточно быстрый обход по дереву. В данный момент нет различия между верхним и нижним регистром. Если аргумент какой-либо функции лежит вне её области определения, то возвращается NaN. @xref{Textual formulas}. 2182 2183@deftypefn {Конструктор класса @code{mglExpr}} @code{} mglExpr (@code{const char *}expr) 2184@deftypefnx {Конструктор класса @code{mglExprC}} @code{} mglExprC (@code{const char *}expr) 2185@deftypefnx {Функция С} @code{HMEX} mgl_create_expr (@code{const char *}expr) 2186@deftypefnx {Функция С} @code{HAEX} mgl_create_cexpr (@code{const char *}expr) 2187Разбирает формулу @var{expr} и создает древовидную структуру, содержащую последовательность вызова функций и операторов для последующего быстрого вычисления формулы с помощью функций @code{Calc()} и/или @code{CalcD()}. 2188@end deftypefn 2189 2190@deftypefn {Destructor on @code{mglExpr}} @code{} ~mglExpr () 2191@deftypefnx {Destructor on @code{mglExprC}} @code{} ~mglExprC () 2192@deftypefnx {Функция С} @code{void} mgl_delete_expr (@code{HMEX} ex) 2193@deftypefnx {Функция С} @code{void} mgl_delete_cexpr (@code{HAEX} ex) 2194Удаляет объект типа @code{mglExpr}. 2195@end deftypefn 2196 2197@deftypefn {Метод класса @code{mglExpr}} @code{mreal} Eval (@code{mreal} x, @code{mreal} y, @code{mreal} z) 2198@deftypefnx {Метод класса @code{mglExprC}} @code{dual} Eval (@code{dual} x, @code{dual} y, @code{dual} z) 2199@deftypefnx {Функция С} @code{mreal} mgl_expr_eval (@code{HMEX} ex, @code{mreal} x, @code{mreal} y, @code{mreal} z) 2200@deftypefnx {Функция С} @code{dual} mgl_cexpr_eval (@code{HAEX} ex, @code{dual} x, @code{dual} y, @code{dual} z) 2201Вычисляет значение формулы для @code{'x','r'}=@var{x}, @code{'y','n'}=@var{y}, @code{'z','t'}=@var{z}, @code{'a','u'}=@var{u}. 2202@end deftypefn 2203 2204@deftypefn {Метод класса @code{mglExpr}} @code{mreal} Eval (@code{mreal} var[26]) 2205@deftypefnx {Метод класса @code{mglExprC}} @code{dual} Eval (@code{dual} var[26]) 2206@deftypefnx {Функция С} @code{mreal} mgl_expr_eval_v (@code{HMEX} ex, @code{mreal *}var) 2207@deftypefnx {Функция С} @code{dual} mgl_cexpr_eval_v (@code{HMEX} ex, @code{dual *}var) 2208Вычисляет значение формулы для переменных в массиве @var{var}[0,...,'z'-'a']. 2209@end deftypefn 2210 2211 2212@deftypefn {Метод класса @code{mglExpr}} @code{mreal} Diff (@code{char} dir, @code{mreal} x, @code{mreal} y, @code{mreal} z) 2213@deftypefnx {Функция С} @code{mreal} mgl_expr_diff (@code{HMEX} ex, @code{char} dir, @code{mreal} x, @code{mreal} y, @code{mreal} z) 2214Вычисляет производную от формулы по переменной @var{dir} для @code{'x','r'}=@var{x}, @code{'y','n'}=@var{y}, @code{'z','t'}=@var{z}, @code{'a','u'}=@var{u}. 2215@end deftypefn 2216 2217@deftypefn {Метод класса @code{mglExpr}} @code{mreal} Diff (@code{char} dir, @code{mreal} var[26]) 2218@deftypefnx {Функция С} @code{mreal} mgl_expr_diff_v (@code{HMEX} ex, @code{char} dir, @code{mreal *}var) 2219Вычисляет производную от формулы по переменной @var{dir} для переменных в массиве @var{var}[0,...,'z'-'a']. 2220@end deftypefn 2221 2222@end ifclear 2223 2224@c ------------------------------------------------------------------ 2225@external{} 2226@node Special data classes, , Evaluate expression, Data processing 2227@section Special data classes 2228@nav{} 2229 2230@ifset UDAV 2231MGL использует специальные классы автоматически. 2232@end ifset 2233 2234@ifclear UDAV 2235Раздел описывает специальные классы данных @code{mglDataV}, @code{mglDataF}, @code{mglDataT} и @code{mglDataR}, которые могут заметно ускорить рисование и обработку данных. Классы определены в @code{#include <mgl2/data.h>}. Отмечу, что все функции рисования и обработки данных можно выполнить используя только основные классы @code{mglData} и/или @code{mglDataC}. Также специальные классы доступны только в коде на С++. 2236 2237@heading Класс @code{mglDataV} 2238представляет переменную со значениями равнораспределенными в заданном интервале. 2239@deftypefn {Конструктор @code{mglDataV}} @code{} mglDataV (@code{const mglDataV &} d) 2240Конструктор копирования. 2241@end deftypefn 2242@deftypefn {Конструктор @code{mglDataV}} @code{} mglDataV (@code{long} nx=@code{1}, @code{long} ny=@code{1}, @code{long} nz=@code{1}, @code{mreal} v1=@code{0}, @code{mreal} v2=@code{NaN}, @code{char} dir=@code{'x'}) 2243Создает переменную "размером" @var{nx}x@var{ny}x@var{nz}, изменяющуюся от @var{v1} до @var{v2} (или постоянную при @var{v2}=@code{NaN}) вдоль направления @var{dir}. 2244@end deftypefn 2245@deftypefn {Метод класса @code{mglDataV}} @code{void} Create (@code{long} nx=@code{1}, @code{long} ny=@code{1}, @code{long} nz=@code{1}) 2246Задает "размеры" переменной @var{nx}x@var{ny}x@var{nz}. 2247@end deftypefn 2248@deftypefn {Метод класса @code{mglDataV}} @code{void} Fill (@code{mreal} x1, @code{mreal} x2=@code{NaN}, @code{char} dir=@code{'x'}) 2249Задает диапазон изменения переменной. 2250@end deftypefn 2251@deftypefn {Метод класса @code{mglDataV}} @code{void} Freq (@code{mreal} dp, @code{char} dir=@code{'x'}) 2252Задает переменную для частоты с шагом @var{dp}. 2253@end deftypefn 2254 2255@heading Класс @code{mglDataF} 2256представляет функцию, которая будет вызываться вместо обращения к элементам массива (как в классе @code{mglData}). 2257@deftypefn {Конструктор @code{mglDataF}} @code{} mglDataF (@code{const mglDataF &} d) 2258Конструктор копирования. 2259@end deftypefn 2260@deftypefn {Конструктор @code{mglDataF}} @code{} mglDataF (@code{long} nx=@code{1}, @code{long} ny=@code{1}, @code{long} nz=@code{1}) 2261Создает данные "размером" @var{nx}x@var{ny}x@var{nz} с нулевой функцией. 2262@end deftypefn 2263@deftypefn {Метод класса @code{mglDataF}} @code{void} Create (@code{long} nx=@code{1}, @code{long} ny=@code{1}, @code{long} nz=@code{1}) 2264Задает "размеры" данных @var{nx}x@var{ny}x@var{nz}. 2265@end deftypefn 2266@deftypefn {Метод класса @code{mglDataF}} @code{void} SetRanges (@code{mglPoint} p1, @code{mglPoint} p2) 2267Задает диапазоны изменения внутренних переменных x,y,z. 2268@end deftypefn 2269@deftypefn {Метод класса @code{mglDataF}} @code{void} SetFormula (@code{const char *}func) 2270Задает строку, которая будет разобрана в функцию. Это вариант более чем 10 раз медленнее в сравнении с @code{SetFunc}(). 2271@end deftypefn 2272@deftypefn {Метод класса @code{mglDataF}} @code{void} SetFunc (@code{mreal (*}f@code{)(mreal x,mreal y,mreal z,void *p)}, @code{void *}p=@code{NULL}) 2273Задает указатель на функцию, которая будет использована вместо доступа к элементам массива. 2274@end deftypefn 2275 2276@heading Класс @code{mglDataT} 2277представляет именнованную ссылку на столбец в другом массиве данных. 2278@deftypefn {Конструктор @code{mglDataT}} @code{} mglDataT (@code{const mglDataT &} d) 2279Конструктор копирования. 2280@end deftypefn 2281@deftypefn {Конструктор @code{mglDataT}} @code{} mglDataT (@code{const mglDataA &} d, @code{long} col=@code{0}) 2282Создает ссылку на @var{col}-ый столбец данных @var{d}. 2283@end deftypefn 2284@deftypefn {Метод класса @code{mglDataT}} @code{void} SetInd (@code{long} col, @code{wchar_t} name) 2285@deftypefnx {Метод класса @code{mglDataT}} @code{void} SetInd (@code{long} col, @code{const wchar_t *} name) 2286Задает ссылку на другой столбец того же массива данных. 2287@end deftypefn 2288 2289 2290@heading Класс @code{mglDataR} 2291представляет именнованную ссылку на строку в другом массиве данных. 2292@deftypefn {Конструктор @code{mglDataR}} @code{} mglDataR (@code{const mglDataR &} d) 2293Конструктор копирования. 2294@end deftypefn 2295@deftypefn {Конструктор @code{mglDataR}} @code{} mglDataR (@code{const mglDataA &} d, @code{long} row=@code{0}) 2296Создает ссылку на @var{row}-ую строку данных @var{d}. 2297@end deftypefn 2298@deftypefn {Метод класса @code{mglDataR}} @code{void} SetInd (@code{long} row, @code{wchar_t} name) 2299@deftypefnx {Метод класса @code{mglDataR}} @code{void} SetInd (@code{long} row, @code{const wchar_t *} name) 2300Задает ссылку на другой столбец того же массива данных. 2301@end deftypefn 2302 2303 2304@heading Class @code{mglDataW} 2305представляет часоту для FFT в виде массива данных. 2306@deftypefn {Конструктор @code{mglDataW}} @code{} mglDataW (@code{const mglDataW &} d) 2307Конструктор копирования. 2308@end deftypefn 2309@deftypefn {Конструктор @code{mglDataW}} @code{} mglDataW (@code{long} xx=@code{1}, @code{long} yy=@code{1}, @code{long} zz=@code{1}, @code{double} dp=@code{0}, @code{char} dir=@code{'x'}) 2310Задает размеры, направление @var{dir} и шаг @var{dp} для частоты. 2311@end deftypefn 2312@deftypefn {Метод класса @code{mglDataR}} @code{void} Freq (@code{double} dp, @code{char} dir=@code{'x'}) 2313Равномерно распределяет данные с шагом @var{dp} в направлении @var{dir}. 2314@end deftypefn 2315 2316 2317@heading Class @code{mglDataS} 2318представляет std::vector в виде массива данных. 2319@deftypecv {Variable} mglDataS @code{std::vector<mreal>} dat 2320Собственно данные. 2321@end deftypecv 2322@deftypefn {Конструктор @code{mglDataS}} @code{} mglDataS (@code{const mglDataS &} d) 2323Конструктор копирования. 2324@end deftypefn 2325@deftypefn {Конструктор @code{mglDataS}} @code{} mglDataS (@code{const std::vector<mreal> &} d) 2326Копирует данные из @var{d}. 2327@end deftypefn 2328@deftypefn {Конструктор @code{mglDataS}} @code{} mglDataS (@code{size_t} s) 2329Выделяет память для @var{s} элементов. 2330@end deftypefn 2331@deftypefn {Метод класса @code{mglDataS}} @code{void} reserve (@code{size_t} num) 2332Резервирует место для @var{num} элементов. 2333@end deftypefn 2334@deftypefn {Метод класса @code{mglDataS}} @code{void} push_back (@code{double} v) 2335Добавляет значение @var{v} к концу массива данных. 2336@end deftypefn 2337 2338 2339@end ifclear 2340 2341@external{} 2342