MathGL 2.4.3
Table of Contents
- 1 Обзор MathGL
- 2 Примеры MathGL
- 2.1 Основы использования
- 2.2 Advanced usage
- 2.3 Data handling
- 2.4 Data plotting
- 2.5 Hints
- 2.5.1 “Compound” graphics
- 2.5.2 Transparency and lighting
- 2.5.3 Types of transparency
- 2.5.4 Axis projection
- 2.5.5 Adding fog
- 2.5.6 Lighting sample
- 2.5.7 Using primitives
- 2.5.8 STFA sample
- 2.5.9 Mapping visualization
- 2.5.10 Data interpolation
- 2.5.11 Making regular data
- 2.5.12 Making histogram
- 2.5.13 Nonlinear fitting hints
- 2.5.14 PDE solving hints
- 2.5.15 Drawing phase plain
- 2.5.16 Pulse properties
- 2.5.17 Using MGL parser
- 2.5.18 Using options
- 2.5.19 “Templates”
- 2.5.20 Stereo image
- 2.5.21 Reduce memory usage
- 2.5.22 Scanning file
- 2.5.23 Mixing bitmap and vector output
- 2.6 FAQ
- 3 Основные принципы
- 4 Ядро MathGL
- 4.1 Создание и удаление графического объекта
- 4.2 Настройка графика
- 4.3 Настройки осей координат
- 4.4 Матрица преобразования
- 4.5 Экспорт рисунка
- 4.6 Фоновое изображение
- 4.7 Рисование примитивов
- 4.8 Вывод текста
- 4.9 Оси и Colorbar
- 4.10 Легенда
- 4.11 1D графики
- 4.12 2D графики
- 4.13 3D графики
- 4.14 Парные графики
- 4.15 Векторные поля
- 4.16 Прочие графики
- 4.17 Nonlinear fitting
- 4.18 Распределение данных
- 5 “Оконные” классы
- 6 Обработка данных
- 6.1 Переменные
- 6.2 Создание и удаление данных
- 6.3 Изменение размеров данных
- 6.4 Заполнение данных
- 6.5 Чтение/сохранение данных
- 6.6 Make another data
- 6.7 Изменение данных
- 6.8 Интерполяция
- 6.9 Информационные функции
- 6.10 Операторы
- 6.11 Глобальные функции
- 6.12 Вычисление выражений
- 6.13 Special data classes
- 7 Скрипты MGL
- 8 UDAV
- 9 Other classes
- 10 All samples
- 10.1 Functions for initialization
- 10.2 Sample ‘3wave’
- 10.3 Sample ‘alpha’
- 10.4 Sample ‘apde’
- 10.5 Sample ‘area’
- 10.6 Sample ‘aspect’
- 10.7 Sample ‘axial’
- 10.8 Sample ‘axis’
- 10.9 Sample ‘barh’
- 10.10 Sample ‘bars’
- 10.11 Sample ‘belt’
- 10.12 Sample ‘bifurcation’
- 10.13 Sample ‘box’
- 10.14 Sample ‘boxplot’
- 10.15 Sample ‘boxs’
- 10.16 Sample ‘candle’
- 10.17 Sample ‘chart’
- 10.18 Sample ‘cloud’
- 10.19 Sample ‘colorbar’
- 10.20 Sample ‘combined’
- 10.21 Sample ‘cones’
- 10.22 Sample ‘cont’
- 10.23 Sample ‘cont3’
- 10.24 Sample ‘cont_xyz’
- 10.25 Sample ‘contd’
- 10.26 Sample ‘contf’
- 10.27 Sample ‘contf3’
- 10.28 Sample ‘contf_xyz’
- 10.29 Sample ‘contv’
- 10.30 Sample ‘correl’
- 10.31 Sample ‘curvcoor’
- 10.32 Sample ‘cut’
- 10.33 Sample ‘dat_diff’
- 10.34 Sample ‘dat_extra’
- 10.35 Sample ‘data1’
- 10.36 Sample ‘data2’
- 10.37 Sample ‘dens’
- 10.38 Sample ‘dens3’
- 10.39 Sample ‘dens_xyz’
- 10.40 Sample ‘detect’
- 10.41 Sample ‘dew’
- 10.42 Sample ‘diffract’
- 10.43 Sample ‘dilate’
- 10.44 Sample ‘dots’
- 10.45 Sample ‘earth’
- 10.46 Sample ‘error’
- 10.47 Sample ‘error2’
- 10.48 Sample ‘export’
- 10.49 Sample ‘fall’
- 10.50 Sample ‘fexport’
- 10.51 Sample ‘fit’
- 10.52 Sample ‘flame2d’
- 10.53 Sample ‘flow’
- 10.54 Sample ‘flow3’
- 10.55 Sample ‘fog’
- 10.56 Sample ‘fonts’
- 10.57 Sample ‘grad’
- 10.58 Sample ‘hist’
- 10.59 Sample ‘ifs2d’
- 10.60 Sample ‘ifs3d’
- 10.61 Sample ‘indirect’
- 10.62 Sample ‘inplot’
- 10.63 Sample ‘iris’
- 10.64 Sample ‘label’
- 10.65 Sample ‘lamerey’
- 10.66 Sample ‘legend’
- 10.67 Sample ‘light’
- 10.68 Sample ‘loglog’
- 10.69 Sample ‘map’
- 10.70 Sample ‘mark’
- 10.71 Sample ‘mask’
- 10.72 Sample ‘mesh’
- 10.73 Sample ‘mirror’
- 10.74 Sample ‘molecule’
- 10.75 Sample ‘ode’
- 10.76 Sample ‘ohlc’
- 10.77 Sample ‘param1’
- 10.78 Sample ‘param2’
- 10.79 Sample ‘param3’
- 10.80 Sample ‘paramv’
- 10.81 Sample ‘parser’
- 10.82 Sample ‘pde’
- 10.83 Sample ‘pendelta’
- 10.84 Sample ‘pipe’
- 10.85 Sample ‘plot’
- 10.86 Sample ‘pmap’
- 10.87 Sample ‘primitives’
- 10.88 Sample ‘projection’
- 10.89 Sample ‘projection5’
- 10.90 Sample ‘pulse’
- 10.91 Sample ‘qo2d’
- 10.92 Sample ‘quality0’
- 10.93 Sample ‘quality1’
- 10.94 Sample ‘quality2’
- 10.95 Sample ‘quality4’
- 10.96 Sample ‘quality5’
- 10.97 Sample ‘quality6’
- 10.98 Sample ‘quality8’
- 10.99 Sample ‘radar’
- 10.100 Sample ‘refill’
- 10.101 Sample ‘region’
- 10.102 Sample ‘scanfile’
- 10.103 Sample ‘schemes’
- 10.104 Sample ‘section’
- 10.105 Sample ‘several_light’
- 10.106 Sample ‘solve’
- 10.107 Sample ‘stem’
- 10.108 Sample ‘step’
- 10.109 Sample ‘stereo’
- 10.110 Sample ‘stfa’
- 10.111 Sample ‘style’
- 10.112 Sample ‘surf’
- 10.113 Sample ‘surf3’
- 10.114 Sample ‘surf3a’
- 10.115 Sample ‘surf3c’
- 10.116 Sample ‘surf3ca’
- 10.117 Sample ‘surfa’
- 10.118 Sample ‘surfc’
- 10.119 Sample ‘surfca’
- 10.120 Sample ‘table’
- 10.121 Sample ‘tape’
- 10.122 Sample ‘tens’
- 10.123 Sample ‘ternary’
- 10.124 Sample ‘text’
- 10.125 Sample ‘text2’
- 10.126 Sample ‘textmark’
- 10.127 Sample ‘ticks’
- 10.128 Sample ‘tile’
- 10.129 Sample ‘tiles’
- 10.130 Sample ‘torus’
- 10.131 Sample ‘traj’
- 10.132 Sample ‘triangulation’
- 10.133 Sample ‘triplot’
- 10.134 Sample ‘tube’
- 10.135 Sample ‘type0’
- 10.136 Sample ‘type1’
- 10.137 Sample ‘type2’
- 10.138 Sample ‘vect’
- 10.139 Sample ‘vect3’
- 10.140 Sample ’venn’
- Appendix A Symbols and hot-keys
- Appendix B File formats
- Appendix C Время отрисовки
- Appendix D Символы TeX
- Appendix E GNU Free Documentation License
- Индекс
MathGL
Это документация для MathGL (версии 2.4.3) – библиотеки классов и функций для построения научной графики. Пожалуйста сообщайте о любых ошибках в этом руководстве на mathgl.abalakin@gmail.org. Дополнительную информацию о MathGL можно найти на домашней странице проекта http://mathgl.sourceforge.net/.
Copyright © 2008-2012 Alexey A. Balakin.
Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.2 or any later version published by the Free Software Foundation; with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. A copy of the license is included in the section entitled “GNU Free Documentation License.”
| • Overview: | ||
| • Examples: | ||
| • General concepts: | ||
| • MathGL core: | ||
| • Widget classes: | ||
| • Data processing: | ||
| • MGL scripts: | ||
| • UDAV: | ||
| • Other classes: | ||
| • All samples: | ||
| • Symbols and hot-keys: | ||
| • File formats: | ||
| • TeX-like symbols: | ||
| • Plotting time: | ||
| • Copying This Manual: | ||
| • Index: |
1 Обзор MathGL
MathGL это ...
- библиотека для создания высококачественной научной графики под Linux и Windows;
- библиотека для быстрого обработки и отображения больших массивов данных;
- библиотека для работы в оконном и консольном режимах;
- библиотека с большим набором базовых типов графиков.
| • What is MathGL?: | ||
| • MathGL features: | ||
| • Installation: | ||
| • Quick guide: | ||
| • Changes from v.1: | ||
| • Utilities: | ||
| • Thanks: |
Next: MathGL features, Up: Overview [Contents][Index]
1.1 Что такое MathGL?
Код для создания качественной научной графики на различных платформах. Код для быстрой обработки и отображения больших массивов данных. Код для работы в графическом и консольном режимах и легкого интегрирования в другие программы. Код с большим обновляемым набором графиков и инструментами обработки данных. Именно такого кода мне не хватало в последние годы при работе на персональных компьютерах и на кластерах. И именно такой код я постарался создать в библиотеке MathGL.
На данный момент (версия 2.4.3) MathGL это более 50 основных типов графиков для одно-, двух- и трехмерных массивов, возможность экспорта в растровые и векторные (EPS или SVG) файлы, интерфейс для OpenGL и возможность запуска в консольном режиме, функции для обработки данных и даже простейший командный (интерпретируемый) язык MGL для упрощения построения графиков. Кроме того, есть несколько типов прозрачности, гладкое освещение, векторные шрифты, TeX-ие команды в надписях, произвольные криволинейные системы координат и прочие полезные мелочи (см. раздел pictures на домашней странице). Ну, и, естественно, полная переносимость библиотеки и ее свободное распространение под лицензией GPL v.2.0 или более поздней.
Next: Installation, Previous: What is MathGL?, Up: Overview [Contents][Index]
1.2 Возможности MathGL
Библиотека MathGL позволяет строить широкий класс графиков, включая:
- рисование одномерных массивов (Plot, Area, Bars, Step, Stem, Torus, Chart, Error, Tube, Mark, see 1D plotting);
- рисование двумерных массивов (Mesh, Surf, Dens, Cont, ContF, Boxs, Axial, Fall, Belt, Tile, see 2D plotting);
- рисование трехмерных массивов (Surf3, Dens3, Cont3, ContF3, Cloud-like, see 3D plotting);
- рисование нескольких связанных массивов: векторные поля Vect, линии тока Flow, точечное отображение Map, поверхности с прозрачностью или цветом, определяемым другим массивом SurfA, SurfC, Surf3A, Surf3C (see Dual plotting);
- и другие (см. see MathGL core).
Фактически, я постарался реализовать все известные мне типы научных графиков. Список графиков постоянно пополняется, и если Вам нужен какой-то новый вариант, пишите на e-mail, и в новой версии библиотеки этот график появится.
Я постарался сделать графики максимально красивыми – поверхности могут быть прозрачными и освещены произвольно расположенными источниками света (максимальное их количество 10). Большинство функций рисования имеет два варианта: простой для быстрого построения картинки и более сложный для детальной настройки отображения, включающего в том числе возможность параметрического задания всех массивов. Получившееся изображение можно сохранить в растровом формате PNG, JPEG, GIF, TGA или BMP; в векторном EPS, SVG или TeX формате, или в 3D формате OBJ, OFF, STL, или в PRC формате, который может быть конвертирован U3D.
Все надписи выводятся векторным шрифтом, что обеспечивает их хорошую масштабируемость и переносимость. Текст может содержать команды для большинства ТеХ-их символов, изменения положения (верхний и нижний индексы) и стиля шрифта внутри строки текста (see Font styles). Текст меток поворачивается вместе с осями. На график можно вывести описание кривых (легенду) и поместить надпись в произвольную точку экрана или пустить ее вдоль кривой. Поддерживаются произвольные кодировки текста (с помощью стандартной функции setlocale()) и текст в кодировке UTF-16.
Для представления данных используется специальный класс mglData (see Data processing). Помимо безопасного создания и удаления массивов, он включает функции по их обработке (дифференцированию, интегрированию, сглаживанию, интерполяции и т.д.) и чтению текстового файла с автоматическим определением размеров данных. Класс mglData позволяет работать с массивами размерности вплоть до 3 (массивы, зависящие от трех независимых индексов a_{ijk}). Использование массивов с большим числом размерностей нецелесообразно, поскольку я не представляю, как их можно отобразить на экране. Заполнение или изменение значений массива можно выполнить как вручную, так и по формуле, заданной текстовой строкой.
Для быстрого вычисления значения выражения, заданного текстовой строкой (see Textual formulas). Он основан на компиляции строки в древоподобную структуру при создании экземпляра класса. На этапе вычисления происходит быстрый обход дерева с выдачей результата для конкретных значений переменных. Помимо изменения значений массива данных, текстовые формулы используются для рисования в произвольной криволинейной системе координат. Набор таких координат ограничивается только фантазией пользователя, а не фиксированным числом (типа полярной, параболической, цилиндрической и т.д.).
Next: Quick guide, Previous: MathGL features, Up: Overview [Contents][Index]
1.3 Установка MathGL
Установка библиотеки возможна 4-мя способами.
- Скомпилировать библиотеку непосредственно из исходных файлов. С библиотекой поставляется файлы для системы сборки CMake. Для его запуска достаточно в командной строке выполнить 3 команды: сначала
cmake .дважды, далееmakeи, наконец, с правами суперпользователяmake install. Иногда после компиляции библиотеки может потребоваться обновление списка библиотека в системе – выполните командуldconfigс правами суперпользователя.Есть несколько дополнительных опций, которые по умолчанию отключены. К их числу относятся:
enable-fltk, enable-glut, enable-qt4, enable-qt5для поддержки FLTK, GLUT и/или Qt окон;enable-jpeg, enable-gif, enable-hdf5для поддержки соответствующих форматов;enable-allдля включения всех возможностей. Для использования типаdoubleдля внутреннего хранения данных используйте опциюenable-double. Для создания интерфейсов к другим языкам (кроме С/Фортран/MGL) используйте опцииenable-python, enable-octaveилиenable-all-swigдля всех поддерживаемых языков. Вы можете воспользоваться WYSIWYG утилитой (cmake-gui) для просмотра и изменения всех опций, или выполнитьcmake -D enable-all=on -D enable-all-widgets=on -D enable-all-swig=on .в командной строке для включения всех опций.При сборке с помощью MinGW необходимо дополнительно установить опцию сборки
-fopenmp(т.е.CMAKE_EXE_LINKER_FLAGS:STRING='-fopenmp'иCMAKE_SHARED_LINKER_FLAGS:STRING='-fopenmp') если включена поддержка OpenMP (enable-openmp=ON). - Использовать предварительно скомпилированные файлы – с библиотекой поставляются файлы для MinGW (платформа Win32). В скомпилированной версии достаточно распаковать заголовочные файлы в папку с заголовочными файлами и библиотеку libmgl.a в папку с библиотеками. По умолчанию, скомпилированная версия включают поддержку GSL (www.gsl.org), PNG, GIF и JPEG. Соответственно, при сборке программы эти библиотеки должны быть установлены (их можно найти на http://gnuwin32.sourceforge.net/packages.html).
- Установить из стандартных пакетов (RPM, deb, DevPak и пр.).
Последнюю версию (которая может быть не стабильна) можно загрузить с sourceforge.net SVN с помощью команды
svn checkout http://svn.code.sf.net/p/mathgl/code/mathgl-2x mathgl-code
ВАЖНО! MathGL использует набор defines, определяемых на этапе конфигурирования библиотеки. Это MGL_SYS_NAN, MGL_HAVE_TYPEOF, MGL_HAVE_PTHREAD, MGL_HAVE_ATTRIBUTE, MGL_HAVE_C99_COMPLEX, MGL_HAVE_RVAL. Они могут отличаться при использовании бинарников скомпилированных другим компилятором (например при использовании скомпилированных MinGW бинарников в VisualStudio). Я специально устанавливаю их в 0 для компиляторов Borland и Microsoft из соображений совместимости. Кроме того, настройки по умолчанию подходят для компиляторов GNU (gcc, mingw) и clang. Однако, для прочих компиляторов может потребоваться ручная установка defines в 0 в файле include/mgl2/config.h если вы используете предварительно скомпилированные файлы.
Next: Changes from v.1, Previous: Installation, Up: Overview [Contents][Index]
1.4 Quick guide
There are 3 steps to prepare the plot in MathGL: (1) prepare data to be plotted, (2) setup plot, (3) plot data. Let me show this on the example of surface plotting.
First we need the data. MathGL use its own class mglData to handle data arrays (see Data processing). This class give ability to handle data arrays by more or less format independent way. So, create it
int main()
{
mglData dat(30,40); // data to for plotting
for(long i=0;i<30;i++) for(long j=0;j<40;j++)
dat.a[i+30*j] = 1/(1+(i-15)*(i-15)/225.+(j-20)*(j-20)/400.);
Here I create matrix 30*40 and initialize it by formula. Note, that I use long type for indexes i, j because data arrays can be really large and long type will automatically provide proper indexing.
Next step is setup of the plot. The only setup I need is axis rotation and lighting.
mglGraph gr; // class for plot drawing
gr.Rotate(50,60); // rotate axis
gr.Light(true); // enable lighting
Everything is ready. And surface can be plotted.
gr.Surf(dat); // plot surface
Basically plot is done. But I decide to add yellow (‘y’ color, see Color styles) contour lines on the surface. To do it I can just add:
gr.Cont(dat,"y"); // plot yellow contour lines
This demonstrate one of base MathGL concept (see, General concepts) – “new drawing never clears things drawn already”. So, you can just consequently call different plotting functions to obtain “combined” plot. For example, if one need to draw axis then he can just call one more plotting function
gr.Axis(); // draw axis
Now picture is ready and we can save it in a file.
gr.WriteFrame("sample.png"); // save it
}
To compile your program, you need to specify the linker option -lmgl.
This is enough for a compilation of console program or with external (non-MathGL) window library. If you want to use FLTK or Qt windows provided by MathGL then you need to add the option -lmgl-wnd.
При использовании фортрана необходимо также включить библиотеку -lstdc++. Кроме того, если библиотека была собрана с опцией enable-double=ON (по умолчанию в версии 2.1 и более поздних), то все вещественные числа должны быть типа real*8. Это можно включить по умолчанию опцией -fdefault-real-8.
Next: Utilities, Previous: Quick guide, Up: Overview [Contents][Index]
1.5 Changes from v.1.*
There are a lot of changes for v.2. Here I denote only main of them.
- mglGraph class is single plotter class instead of mglGraphZB, mglGraphPS and so on.
- Text style and text color positions are swapped. I.e. text style ‘r:C’ give red centered text, but not roman dark cyan text as for v.1.*.
- ColumnPlot() indexing is reverted.
- Move most of arguments of plotting functions into the string parameter and/or options.
- “Bright” colors (like {b8}) can be used in color schemes and line styles.
- Intensively use pthread internally for parallelization of drawing and data processing.
- Add tick labels rotation and skipping. Add ticks in time/date format.
- New kinds of plots (Tape(), Label(), Cones(), ContV()). Extend existing plots. New primitives (Circle(), Ellipse(), Rhomb(), ...). New plot positioning (MultiPlot(), GridPlot())
- Improve MGL scripts. Add ’ask’ command and allow string concatenation from different lines.
- Export to LaTeX and to 3D formats (OBJ, OFF, STL).
- Add pipes support in utilities (
mglconv, mglview).
Next: Thanks, Previous: Changes from v.1, Up: Overview [Contents][Index]
1.6 Utilities for parsing MGL
MathGL library provides several tools for parsing MGL scripts. There is tools saving it to bitmap or vectorial images (mglconv). Tool mglview show MGL script and allow to rotate and setup the image. Another feature of mglview is loading *.mgld files (see ExportMGLD()) for quick viewing 3d pictures.
Both tools have similar set of arguments. They can be name of script file or options. You can use ‘-’ as script name for using standard input (i.e. pipes). Options are:
- -1 str set str as argument $1 for script;
- ... ...
- -9 str set str as argument $9 for script;
- -L loc set locale to loc;
- -s fname set MGL script for setting up the plot;
- -h print help message.
Additionally mglconv have following options:
- -A val add val into the list of animation parameters;
- -C v1:v2[:dv] add values from v1 ot v2 with step dv (default is 1) into the list of animation parameters;
- -o name set output file name;
- -n disable default output (script should save results by itself);
- -S val set set scaling factor for setsize;
- -q val set quality for output (val=0...9).
Also you can create animated GIF file or a set of JPEG files with names ‘frameNNNN.jpg’ (here ‘NNNN’ is frame index). Values of the parameter $0 for making animation can be specified inside the script by comment ##a val for each value val (one comment for one value) or by option(s) ‘-A val’. Also you can specify a cycle for animation by comment ##c v1 v2 dv or by option -C v1:v2:dv. In the case of found/specified animation parameters, tool will execute script several times – once for each value of $0.
MathGL also provide another simple tool mgl.cgi which parse MGL script from CGI request and send back produced PNG file. Usually this program should be placed in /usr/lib/cgi-bin/. But you need to put this program by yourself due to possible security issues and difference of Apache server settings.
1.7 Благодарности
- Моя специальная благодарность моей жене за терпение во время написания библиотеки.
- Я благодарен моим соавторам Д. Кулагину и М. Видассову за помощь в разработке MathGL.
- Я благодарен Diego Sejas Viscarra за разработку mgltex, вклад в генерацию фракталов и продуктивные предложения и обсуждения.
- Я благодарен D. Eftaxiopoulos, D. Haley, В. Липатову и С. Плису за создание бинарных пакетов для Linux.
- Я благодарен С. Скобелеву, К. Михайленко, М. Вейсману, A. Прохорову, A. Короткевичу, В. Онучину, С. Плису, Р. Киселеву, A. Иванову, Н. Троицкому and В. Липатову за продуктивные предложения и обсуждения.
- Я благодарен спонсорам М. Вейсману (ОИВТ РАН) и A. Прохорову (DATADVANCE).
Javascript интерфейс был разработан при поддержке компании DATADVANCE.
Next: General concepts, Previous: Overview, Up: Top [Contents][Index]
2 Примеры MathGL
В данной главе рассмотрены базовые и продвинутые возможности MathGL, даны советы по использованию и примеры для всех типов графиков. Я рекомендую прочитать вначале первые 2 раздела и посмотреть на раздел Hints. Также рекомендую прочитать General concepts и FAQ.
Отмечу, что MathGL v.2.* имеет только пользовательских 2 интерфейса: один для языков подобных C или Fortran (не поддерживающих классы), другой для языков подобных C++/Python/Octave, которые поддерживают классы. При этом все классы являются "оберткой" С-ого интерфейсы, а функции-члены классов – inline вызовами функций С. Поэтому, в большинстве примеров в этой главе я буду приводить только один вариант кода, который после минимальных изменений синтаксиса может быть применен для других языков. Например, код на языке C++
#include <mgl2/mgl.h>
int main()
{
mglGraph gr;
gr.FPlot("sin(pi*x)");
gr.WriteFrame("test.png");
}
на Python будет выглядеть как
from mathgl import *
gr = mglGraph();
gr.FPlot("sin(pi*x)");
gr.WriteFrame("test.png");
в Octave он будет почти тем же (в новых версиях надо предварительно выполнить mathgl;)
gr = mglGraph();
gr.FPlot("sin(pi*x)");
gr.WriteFrame("test.png");
в C необходимо будет найти С-ые аналоги функций (из документации) и указать все их аргументы явно
#include <mgl2/mgl_cf.h>
int main()
{
HMGL gr = mgl_create_graph(600,400);
mgl_fplot(gr,"sin(pi*x)","","");
mgl_write_frame(gr,"test.png","");
mgl_delete_graph(gr);
}
в Fortran помимо этого придется определить функции возвращающие указатели на объекты как функции возвращающие целое
integer gr, mgl_create_graph gr = mgl_create_graph(600,400); call mgl_fplot(gr,'sin(pi*x)','',''); call mgl_write_frame(gr,'test.png',''); call mgl_delete_graph(gr);
и т.д.
| • Basic usage: | ||
| • Advanced usage: | ||
| • Data handling: | ||
| • Data plotting: | ||
| • Hints: | ||
| • FAQ: |
Next: Advanced usage, Up: Examples [Contents][Index]
2.1 Основы использования
Библиотеку MathGL можно использовать несколькими способами, каждый из которых имеет свои достоинства и недостатки:
- Использовать возможности MathGL для создания графического окна (требуется FLTK, Qt или GLUT библиотеки).
Положительная сторона состоит в возможности сразу увидеть график и быстро его мышкой поправить (повернуть, приблизить, выключить прозрачность или освещение и т.д.). Однако, в этом случае требуется наличие графической системы (нельзя запускать на удаленной машине), и работать можно только с одним набором данных одновременно.
- Прямой вывод в файл в растровом или векторном формате, без создания графического окна.
Достоинства такого подхода: пакетная обработка похожих данных (например, набора расчетных файлов при различных условиях), возможность запуска из консольной программы (включая запуск на удаленном компьютере/сервере/кластере), более быстрая и автоматизированная отрисовка, сохранение графиков для последующего анализа непосредственно во время расчета. К недостаткам подхода можно отнести: использование внешней программы просмотра для построенных графиков, необходимость заранее представить картинку (углы просмотра, освещение и пр.). Я рекомендую вначале использовать графическое окно для выбора оптимальных параметров графика, а потом использовать их для пакетной обработки.
- Рисовать график в памяти с последующим выводом на экран другой графической программой.
В этом случае программист имеет максимум свободы в выборе графической библиотеки (не только FLTK, Qt или GLUT), в расположении и выборе элементов управления графиком и т.д. Я рекомендую этот вариант для "самодостаточного" приложения.
- Использовать FLTK или Qt виджеты, предоставляемые MathGL
Вы также можете использовать ряд элементов управления (виджетов), которые позволяют отобразить график, сохранить его в файл в различных форматах или скопировать в буфер обмена, обработать движение/клики мышкой и пр.
Графики MathGL могут быть созданы не только с помощью объектно-ориентированных языков (например, C++ или Python), но и на C или Fortran подобных языках. Использование последних в основном идентичны использованию классов (за исключением различных имен функций). Различие состоит в обязательном предварительном создании (и удалении после использования) объектов типа HMGL (для графики) и/или HMDT (для данных). Пользователи Fortran могут считать эти переменные целочисленными с достаточной разрядностью для используемой операционной системы.
Рассмотрим вышесказанное подробно.
| • Using MathGL window: | ||
| • Drawing to file: | ||
| • Animation: | ||
| • Drawing in memory: | ||
| • Draw and calculate: | ||
| • Using QMathGL: | ||
| • OpenGL output: | ||
| • MathGL and PyQt: | ||
| • MathGL and MPI: |
Next: Drawing to file, Up: Basic usage [Contents][Index]
2.1.1 Использование окон MathGL
“Интерактивный” способ использования MathGL состоит в создании окна с помощью классов mglQT, mglFLTK или mglGLUT (см. Widget classes) и последующем рисовании в этом окне. Соответствующий код выглядит так:
#include <mgl2/qt.h>
int sample(mglGraph *gr)
{
gr->Rotate(60,40);
gr->Box();
return 0;
}
//-----------------------------------------------------
int main(int argc,char **argv)
{
mglQT gr(sample,"MathGL examples");
return gr.Run();
}
Здесь используется callback функция sample, выполняющая собственно рисование. Функция main – точка входа в программу – создает окно (объект gr типа mglQT) и запускает цикл обработки сообщений (вызов gr.Run()). Для компиляции достаточно выполнить команду
gcc test.cpp -lmgl-qt5 -lmgl
Вы можете использовать "-lmgl-qt4" вместо "-lmgl-qt5", если установлен Qt4.
Альтернативный способ состоит в использовании класса, производного от mglDraw с переопределенной функцией Draw():
#include <mgl2/qt.h>
class Foo : public mglDraw
{
public:
int Draw(mglGraph *gr);
};
//-----------------------------------------------------
int Foo::Draw(mglGraph *gr)
{
gr->Rotate(60,40);
gr->Box();
return 0;
}
//-----------------------------------------------------
int main(int argc,char **argv)
{
Foo foo;
mglQT gr(&foo,"MathGL examples");
return gr.Run();
}
Или в использовании функций С:
#include <mgl2/mgl_cf.h>
int sample(HMGL gr, void *)
{
mgl_rotate(gr,60,40,0);
mgl_box(gr);
}
int main(int argc,char **argv)
{
HMGL gr;
gr = mgl_create_graph_qt(sample,"MathGL examples",0,0);
return mgl_qt_run();
/* generally I should call mgl_delete_graph() here,
* but I omit it in main() function. */
}
Похожий код получается и при использовании окон mglFLTK, mglGLUT (функция sample() та же):
#include <mgl2/glut.h>
int main(int argc,char **argv)
{
mglGLUT gr(sample,"MathGL examples");
return 0;
}
The rotation, shift, zooming, switching on/off transparency and lighting can be done with help of tool-buttons (for mglWindow) or by hot-keys: ‘a’, ‘d’, ‘w’, ‘s’ for plot rotation, ‘r’ and ‘f’ switching on/off transparency and lighting. Press ‘x’ for exit (or closing the window).
In this example function sample rotates axes (Rotate(), see Subplots and rotation) and draws the bounding box (Box()). Drawing is placed in separate function since it will be used on demand when window canvas needs to be redrawn.
Next: Animation, Previous: Using MathGL window, Up: Basic usage [Contents][Index]
2.1.2 Drawing to file
Another way of using MathGL library is the direct writing of the picture to the file. It is most usable for plot creation during long calculation or for using of small programs (like Matlab or Scilab scripts) for visualizing repetitive sets of data. But the speed of drawing is much higher in comparison with a script language.
The following code produces a bitmap PNG picture:
#include <mgl2/mgl.h>
int main(int ,char **)
{
mglGraph gr;
gr.Alpha(true); gr.Light(true);
sample(&gr); // The same drawing function.
gr.WritePNG("test.png"); // Don't forget to save the result!
return 0;
}
For compilation, you need only libmgl library not the one with widgets
gcc test.cpp -lmgl
This can be important if you create a console program in computer/cluster where X-server (and widgets) is inaccessible.
The only difference from the previous variant (using windows) is manual switching on the transparency Alpha and lightning Light, if you need it. The usage of frames (see Animation) is not advisable since the whole image is prepared each time. If function sample contains frames then only last one will be saved to the file. In principle, one does not need to separate drawing functions in case of direct file writing in consequence of the single calling of this function for each picture. However, one may use the same drawing procedure to create a plot with changeable parameters, to export in different file types, to emphasize the drawing code and so on. So, in future I will put the drawing in the separate function.
The code for export into other formats (for example, into vector EPS file) looks the same:
#include <mgl2/mgl.h>
int main(int ,char **)
{
mglGraph gr;
gr.Light(true);
sample(&gr); // The same drawing function.
gr.WriteEPS("test.eps"); // Don't forget to save the result!
return 0;
}
The difference from the previous one is using other function WriteEPS() for EPS format instead of function WritePNG(). Also, there is no switching on of the plot transparency Alpha since EPS format does not support it.
Next: Drawing in memory, Previous: Drawing to file, Up: Basic usage [Contents][Index]
2.1.3 Animation
Widget classes (mglWindow, mglGLUT) support a delayed drawing, when all plotting functions are called once at the beginning of writing to memory lists. Further program displays the saved lists faster. Resulting redrawing will be faster but it requires sufficient memory. Several lists (frames) can be displayed one after another (by pressing ‘,’, ‘.’) or run as cinema. To switch these feature on one needs to modify function sample:
int sample(mglGraph *gr)
{
gr->NewFrame(); // the first frame
gr->Rotate(60,40);
gr->Box();
gr->EndFrame(); // end of the first frame
gr->NewFrame(); // the second frame
gr->Box();
gr->Axis("xy");
gr->EndFrame(); // end of the second frame
return gr->GetNumFrame(); // returns the frame number
}
First, the function creates a frame by calling NewFrame() for rotated axes and draws the bounding box. The function EndFrame() must be called after the frame drawing! The second frame contains the bounding box and axes Axis("xy") in the initial (unrotated) coordinates. Function sample returns the number of created frames GetNumFrame().
Note, that animation can be also done as visualization of running calculations (see Draw and calculate).
Pictures with animation can be saved in file(s) as well. You can: export in animated GIF, or save each frame in separate file (usually JPEG) and convert these files into the movie (for example, by help of ImageMagic). Let me show both methods.
The simplest methods is making animated GIF. There are 3 steps: (1) open GIF file by StartGIF() function; (2) create the frames by calling NewFrame() before and EndFrame() after plotting; (3) close GIF by CloseGIF() function. So the simplest code for “running” sinusoid will look like this:
#include <mgl2/mgl.h>
int main(int ,char **)
{
mglGraph gr;
mglData dat(100);
char str[32];
gr.StartGIF("sample.gif");
for(int i=0;i<40;i++)
{
gr.NewFrame(); // start frame
gr.Box(); // some plotting
for(int j=0;j<dat.nx;j++)
dat.a[j]=sin(M_PI*j/dat.nx+M_PI*0.05*i);
gr.Plot(dat,"b");
gr.EndFrame(); // end frame
}
gr.CloseGIF();
return 0;
}
The second way is saving each frame in separate file (usually JPEG) and later make the movie from them. MathGL have special function for saving frames – it is WriteFrame(). This function save each frame with automatic name ‘frame0001.jpg, frame0002.jpg’ and so on. Here prefix ‘frame’ is defined by PlotId variable of mglGraph class. So the similar code will look like this:
#include <mgl2/mgl.h>
int main(int ,char **)
{
mglGraph gr;
mglData dat(100);
char str[32];
for(int i=0;i<40;i++)
{
gr.NewFrame(); // start frame
gr.Box(); // some plotting
for(int j=0;j<dat.nx;j++)
dat.a[j]=sin(M_PI*j/dat.nx+M_PI*0.05*i);
gr.Plot(dat,"b");
gr.EndFrame(); // end frame
gr.WriteFrame(); // save frame
}
return 0;
}
Created files can be converted to movie by help of a lot of programs. For example, you can use ImageMagic (command ‘convert frame*.jpg movie.mpg’), MPEG library, GIMP and so on.
Finally, you can use mglconv tool for doing the same with MGL scripts (see Utilities).
Next: Draw and calculate, Previous: Animation, Up: Basic usage [Contents][Index]
2.1.4 Drawing in memory
The last way of MathGL using is the drawing in memory. Class mglGraph allows one to create a bitmap picture in memory. Further this picture can be displayed in window by some window libraries (like wxWidgets, FLTK, Windows GDI and so on). For example, the code for drawing in wxWidget library looks like:
void MyForm::OnPaint(wxPaintEvent& event)
{
int w,h,x,y;
GetClientSize(&w,&h); // size of the picture
mglGraph gr(w,h);
gr.Alpha(true); // draws something using MathGL
gr.Light(true);
sample(&gr,NULL);
wxImage img(w,h,gr.GetRGB(),true);
ToolBar->GetSize(&x,&y); // gets a height of the toolbar if any
wxPaintDC dc(this); // and draws it
dc.DrawBitmap(wxBitmap(img),0,y);
}
The drawing in other libraries is most the same.
For example, FLTK code will look like
void Fl_MyWidget::draw()
{
mglGraph gr(w(),h());
gr.Alpha(true); // draws something using MathGL
gr.Light(true);
sample(&gr,NULL);
fl_draw_image(gr.GetRGB(), x(), y(), gr.GetWidth(), gr.GetHeight(), 3);
}
Qt code will look like
void MyWidget::paintEvent(QPaintEvent *)
{
mglGraph gr(w(),h());
gr.Alpha(true); // draws something using MathGL
gr.Light(true); gr.Light(0,mglPoint(1,0,-1));
sample(&gr,NULL);
// Qt don't support RGB format as is. So, let convert it to BGRN.
long w=gr.GetWidth(), h=gr.GetHeight();
unsigned char *buf = new uchar[4*w*h];
gr.GetBGRN(buf, 4*w*h)
QPixmap pic = QPixmap::fromImage(QImage(*buf, w, h, QImage::Format_RGB32));
QPainter paint;
paint.begin(this); paint.drawPixmap(0,0,pic); paint.end();
delete []buf;
}
Next: Using QMathGL, Previous: Drawing in memory, Up: Basic usage [Contents][Index]
2.1.5 Draw and calculate
MathGL can be used to draw plots in parallel with some external calculations. The simplest way for this is the usage of mglDraw class. At this you should enable pthread for widgets by setting enable-pthr-widget=ON at configure stage (it is set by default).
First, you need to inherit you class from mglDraw class, define virtual members Draw() and Calc() which will draw the plot and proceed calculations. You may want to add the pointer mglWnd *wnd; to window with plot for interacting with them. Finally, you may add any other data or member functions. The sample class is shown below
class myDraw : public mglDraw
{
mglPoint pnt; // some variable for changeable data
long i; // another variable to be shown
mglWnd *wnd; // external window for plotting
public:
myDraw(mglWnd *w=0) : mglDraw() { wnd=w; }
void SetWnd(mglWnd *w) { wnd=w; }
int Draw(mglGraph *gr)
{
gr->Line(mglPoint(),pnt,"Ar2");
char str[16]; snprintf(str,15,"i=%ld",i);
gr->Puts(mglPoint(),str);
return 0;
}
void Calc()
{
for(i=0;;i++) // do calculation
{
long_calculations();// which can be very long
Check(); // check if need pause
pnt.Set(2*mgl_rnd()-1,2*mgl_rnd()-1);
if(wnd) wnd->Update();
}
}
} dr;
There is only one issue here. Sometimes you may want to pause calculations to view result carefully, or save state, or change something. So, you need to provide a mechanism for pausing. Class mglDraw provide function Check(); which check if toolbutton with pause is pressed and wait until it will be released. This function should be called in a "safety" places, where you can pause the calculation (for example, at the end of time step). Also you may add call exit(0); at the end of Calc(); function for closing window and exit after finishing calculations.
Finally, you need to create a window itself and run calculations.
int main(int argc,char **argv)
{
mglFLTK gr(&dr,"Multi-threading test"); // create window
dr.SetWnd(&gr); // pass window pointer to yours class
dr.Run(); // run calculations
gr.Run(); // run event loop for window
return 0;
}
Note, that you can reach the similar functionality without using mglDraw class (i.e. even for pure C code).
mglFLTK *gr=NULL; // pointer to window
void *calc(void *) // function with calculations
{
mglPoint pnt; // some data for plot
for(long i=0;;i++) // do calculation
{
long_calculations(); // which can be very long
pnt.Set(2*mgl_rnd()-1,2*mgl_rnd()-1);
if(gr)
{
gr->Clf(); // make new drawing
// draw something
gr->Line(mglPoint(),pnt,"Ar2");
char str[16]; snprintf(str,15,"i=%ld",i);
gr->Puts(mglPoint(),str);
// don't forgot to update window
gr->Update();
}
}
}
int main(int argc,char **argv)
{
static pthread_t thr;
pthread_create(&thr,0,calc,0); // create separate thread for calculations
pthread_detach(thr); // and detach it
gr = new mglFLTK; // now create window
gr->Run(); // and run event loop
return 0;
}
This sample is exactly the same as one with mglDraw class, but it don’t have functionality for pausing calculations. If you need it then you have to create global mutex (like pthread_mutex_t *mutex = pthread_mutex_init(&mutex,NULL);), set it to window (like gr->SetMutex(mutex);) and periodically check it at calculations (like pthread_mutex_lock(&mutex); pthread_mutex_unlock(&mutex);).
Finally, you can put the event-handling loop in separate instead of yours code by using RunThr() function instead of Run() one. Unfortunately, such method work well only for FLTK windows and only if pthread support was enabled. Such limitation come from the Qt requirement to be run in the primary thread only. The sample code will be:
int main(int argc,char **argv)
{
mglFLTK gr("test");
gr.RunThr(); // <-- need MathGL version which use pthread for widgets
mglPoint pnt; // some data
for(int i=0;i<10;i++) // do calculation
{
long_calculations();// which can be very long
pnt.Set(2*mgl_rnd()-1,2*mgl_rnd()-1);
gr.Clf(); // make new drawing
gr.Line(mglPoint(),pnt,"Ar2");
char str[10] = "i=0"; str[3] = '0'+i;
gr->Puts(mglPoint(),str);
gr.Update(); // update window
}
return 0; // finish calculations and close the window
}
Next: OpenGL output, Previous: Draw and calculate, Up: Basic usage [Contents][Index]
2.1.6 Using QMathGL
MathGL have several interface widgets for different widget libraries. There are QMathGL for Qt, Fl_MathGL for FLTK. These classes provide control which display MathGL graphics. Unfortunately there is no uniform interface for widget classes because all libraries have slightly different set of functions, features and so on. However the usage of MathGL widgets is rather simple. Let me show it on the example of QMathGL.
First of all you have to define the drawing function or inherit a class from mglDraw class. After it just create a window and setup QMathGL instance as any other Qt widget:
#include <QApplication>
#include <QMainWindow>
#include <QScrollArea>
#include <mgl2/qmathgl.h>
int main(int argc,char **argv)
{
QApplication a(argc,argv);
QMainWindow *Wnd = new QMainWindow;
Wnd->resize(810,610); // for fill up the QMGL, menu and toolbars
Wnd->setWindowTitle("QMathGL sample");
// here I allow to scroll QMathGL -- the case
// then user want to prepare huge picture
QScrollArea *scroll = new QScrollArea(Wnd);
// Create and setup QMathGL
QMathGL *QMGL = new QMathGL(Wnd);
//QMGL->setPopup(popup); // if you want to setup popup menu for QMGL
QMGL->setDraw(sample);
// or use QMGL->setDraw(foo); for instance of class Foo:public mglDraw
QMGL->update();
// continue other setup (menu, toolbar and so on)
scroll->setWidget(QMGL);
Wnd->setCentralWidget(scroll);
Wnd->show();
return a.exec();
}
Next: MathGL and PyQt, Previous: Using QMathGL, Up: Basic usage [Contents][Index]
2.1.7 OpenGL output
MathGL have possibility to draw resulting plot using OpenGL. This produce resulting plot a bit faster, but with some limitations (especially at use of transparency and lighting). Generally, you need to prepare OpenGL window and call MathGL functions to draw it. There is GLUT interface (see Widget classes) to do it by simple way. Below I show example of OpenGL usage basing on Qt libraries (i.e. by using QGLWidget widget).
First, one need to define widget class derived from QGLWidget and implement a few methods: resizeGL() called after each window resize, paintGL() for displaying the image on the screen, and initializeGL() for initializing OpenGL. The header file looks as following.
#ifndef MAINWINDOW_H
#define MAINWINDOW_H
#include <QGLWidget>
#include <mgl2/mgl.h>
class MainWindow : public QGLWidget
{
Q_OBJECT
protected:
mglGraph *gr; // pointer to MathGL core class
void resizeGL(int nWidth, int nHeight); // Method called after each window resize
void paintGL(); // Method to display the image on the screen
void initializeGL(); // Method to initialize OpenGL
public:
MainWindow(QWidget *parent = 0);
~MainWindow();
};
#endif // MAINWINDOW_H
The class implementation is rather straightforward. One need to recreate the instance of mglGraph at initializing OpenGL, and ask MathGL to use OpenGL output (set argument 1 in mglGraph constructor). Of course, the mglGraph object should be deleted at destruction. The method resizeGL() just pass new sizes to OpenGL and update viewport sizes. All plotting functions are located in the method paintGL(). At this, one need to add 2 calls: gr->Clf() at beginning for clearing previous OpenGL primitives; and swapBuffers() for showing output on the screen. The source file looks as following.
#include "qgl_example.h"
#include <QApplication>
//#include <QtOpenGL>
//-----------------------------------------------------------------------------
MainWindow::MainWindow(QWidget *parent) : QGLWidget(parent) { gr=0; }
//-----------------------------------------------------------------------------
MainWindow::~MainWindow() { if(gr) delete gr; }
//-----------------------------------------------------------------------------
void MainWindow::initializeGL() // recreate instance of MathGL core
{
if(gr) delete gr;
gr = new mglGraph(1); // use '1' for argument to force OpenGL output in MathGL
}
//-----------------------------------------------------------------------------
void MainWindow::resizeGL(int w, int h) // standard resize replace
{
QGLWidget::resizeGL(w, h);
glViewport (0, 0, w, h);
}
//-----------------------------------------------------------------------------
void MainWindow::paintGL() // main drawing function
{
gr->Clf(); // clear previous OpenGL primitives
gr->SubPlot(1,1,0);
gr->Rotate(40,60);
gr->Light(true);
gr->AddLight(0,mglPoint(0,0,10),mglPoint(0,0,-1));
gr->Axis();
gr->Box();
gr->FPlot("sin(pi*x)","i2");
gr->FPlot("cos(pi*x)","|");
gr->FSurf("cos(2*pi*(x^2+y^2))");
gr->Finish();
swapBuffers(); // show output on the screen
}
//-----------------------------------------------------------------------------
int main(int argc, char *argv[]) // create application
{
mgl_textdomain(argv?argv[0]:NULL,"");
QApplication a(argc, argv);
MainWindow w;
w.show();
return a.exec();
}
//-----------------------------------------------------------------------------
Next: MathGL and MPI, Previous: OpenGL output, Up: Basic usage [Contents][Index]
2.1.8 MathGL and PyQt
Generally SWIG based classes (including the Python one) are the same as C++ classes. However, there are few tips for using MathGL with PyQt. Below I place a very simple python code which demonstrate how MathGL can be used with PyQt. This code is mostly written by Prof. Dr. Heino Falcke. You can just copy it to a file mgl-pyqt-test.py and execute it from python shell by command execfile("mgl-pyqt-test.py")
from PyQt4 import QtGui,QtCore
from mathgl import *
import sys
app = QtGui.QApplication(sys.argv)
qpointf=QtCore.QPointF()
class hfQtPlot(QtGui.QWidget):
def __init__(self, parent=None):
QtGui.QWidget.__init__(self, parent)
self.img=(QtGui.QImage())
def setgraph(self,gr):
self.buffer='\t'
self.buffer=self.buffer.expandtabs(4*gr.GetWidth()*gr.GetHeight())
gr.GetBGRN(self.buffer,len(self.buffer))
self.img=QtGui.QImage(self.buffer, gr.GetWidth(),gr.GetHeight(),QtGui.QImage.Format_ARGB32)
self.update()
def paintEvent(self, event):
paint = QtGui.QPainter()
paint.begin(self)
paint.drawImage(qpointf,self.img)
paint.end()
BackgroundColor=[1.0,1.0,1.0]
size=100
gr=mglGraph()
y=mglData(size)
#y.Modify("((0.7*cos(2*pi*(x+.2)*500)+0.3)*(rnd*0.5+0.5)+362.135+10000.)")
y.Modify("(cos(2*pi*x*10)+1.1)*1000.*rnd-501")
x=mglData(size)
x.Modify("x^2");
def plotpanel(gr,x,y,n):
gr.SubPlot(2,2,n)
gr.SetXRange(x)
gr.SetYRange(y)
gr.AdjustTicks()
gr.Axis()
gr.Box()
gr.Label("x","x-Axis",1)
gr.Label("y","y-Axis",1)
gr.ClearLegend()
gr.AddLegend("Legend: "+str(n),"k")
gr.Legend()
gr.Plot(x,y)
gr.Clf(BackgroundColor[0],BackgroundColor[1],BackgroundColor[2])
gr.SetPlotFactor(1.5)
plotpanel(gr,x,y,0)
y.Modify("(cos(2*pi*x*10)+1.1)*1000.*rnd-501")
plotpanel(gr,x,y,1)
y.Modify("(cos(2*pi*x*10)+1.1)*1000.*rnd-501")
plotpanel(gr,x,y,2)
y.Modify("(cos(2*pi*x*10)+1.1)*1000.*rnd-501")
plotpanel(gr,x,y,3)
gr.WritePNG("test.png","Test Plot")
qw = hfQtPlot()
qw.show()
qw.setgraph(gr)
qw.raise_()
Previous: MathGL and PyQt, Up: Basic usage [Contents][Index]
2.1.9 MathGL and MPI
For using MathGL in MPI program you just need to: (1) plot its own part of data for each running node; (2) collect resulting graphical information in a single program (for example, at node with rank=0); (3) save it. The sample code below demonstrate this for very simple sample of surface drawing.
First you need to initialize MPI
#include <stdio.h>
#include <mgl2/mpi.h>
#include <mpi.h>
int main(int argc, char *argv[])
{
// initialize MPI
int rank=0, numproc=1;
MPI_Init(&argc, &argv);
MPI_Comm_size(MPI_COMM_WORLD,&numproc);
MPI_Comm_rank(MPI_COMM_WORLD,&rank);
if(rank==0) printf("Use %d processes.\n", numproc);
Next step is data creation. For simplicity, I create data arrays with the same sizes for all nodes. At this, you have to create mglGraph object too.
// initialize data similarly for all nodes mglData a(128,256); mglGraphMPI gr;
Now, data should be filled by numbers. In real case, it should be some kind of calculations. But I just fill it by formula.
// do the same plot for its own range char buf[64]; sprintf(buf,"xrange %g %g",2.*rank/numproc-1,2.*(rank+1)/numproc-1); gr.Fill(a,"sin(2*pi*x)",buf);
It is time to plot the data. Don’t forget to set proper axis range(s) by using parametric form or by using options (as in the sample).
// plot data in each node gr.Clf(); // clear image before making the image gr.Rotate(40,60); gr.Surf(a,"",buf);
Finally, let send graphical information to node with rank=0.
// collect information if(rank!=0) gr.MPI_Send(0); else for(int i=1;i<numproc;i++) gr.MPI_Recv(i);
Now, node with rank=0 have whole image. It is time to save the image to a file. Also, you can add a kind of annotations here – I draw axis and bounding box in the sample.
if(rank==0)
{
gr.Box(); gr.Axis(); // some post processing
gr.WritePNG("test.png"); // save result
}
In my case the program is done, and I finalize MPI. In real program, you can repeat the loop of data calculation and data plotting as many times as you need.
MPI_Finalize(); return 0; }
You can type ‘mpic++ test.cpp -lmgl-mpi -lmgl && mpirun -np 8 ./a.out’ for compilation and running the sample program on 8 nodes. Note, that you have to set enable-mpi=ON at MathGL configure to use this feature.
Next: Data handling, Previous: Basic usage, Up: Examples [Contents][Index]
2.2 Advanced usage
Now I show several non-obvious features of MathGL: several subplots in a single picture, curvilinear coordinates, text printing and so on. Generally you may miss this section at first reading.
| • Subplots: | ||
| • Axis and ticks: | ||
| • Curvilinear coordinates: | ||
| • Colorbars: | ||
| • Bounding box: | ||
| • Ternary axis: | ||
| • Text features: | ||
| • Legend sample: | ||
| • Cutting sample: |
Next: Axis and ticks, Up: Advanced usage [Contents][Index]
2.2.1 Subplots
Let me demonstrate possibilities of plot positioning and rotation. MathGL has a set of functions: subplot, inplot, title, aspect and rotate and so on (see Subplots and rotation). The order of their calling is strictly determined. First, one changes the position of plot in image area (functions subplot, inplot and multiplot). Secondly, you can add the title of plot by title function. After that one may rotate the plot (function rotate). Finally, one may change aspects of axes (function aspect). The following code illustrates the aforesaid it:
int sample(mglGraph *gr)
{
gr->SubPlot(2,2,0); gr->Box();
gr->Puts(mglPoint(-1,1.1),"Just box",":L");
gr->InPlot(0.2,0.5,0.7,1,false); gr->Box();
gr->Puts(mglPoint(0,1.2),"InPlot example");
gr->SubPlot(2,2,1); gr->Title("Rotate only");
gr->Rotate(50,60); gr->Box();
gr->SubPlot(2,2,2); gr->Title("Rotate and Aspect");
gr->Rotate(50,60); gr->Aspect(1,1,2); gr->Box();
gr->SubPlot(2,2,3); gr->Title("Shear");
gr->Box("c"); gr->Shear(0.2,0.1); gr->Box();
return 0;
}
Here I used function Puts for printing the text in arbitrary position of picture (see Text printing). Text coordinates and size are connected with axes. However, text coordinates may be everywhere, including the outside the bounding box. I’ll show its features later in Text features.
More complicated sample show how to use most of positioning functions:
int sample(mglGraph *gr)
{
gr->SubPlot(3,2,0); gr->Title("StickPlot");
gr->StickPlot(3, 0, 20, 30); gr->Box("r"); gr->Puts(mglPoint(0),"0","r");
gr->StickPlot(3, 1, 20, 30); gr->Box("g"); gr->Puts(mglPoint(0),"1","g");
gr->StickPlot(3, 2, 20, 30); gr->Box("b"); gr->Puts(mglPoint(0),"2","b");
gr->SubPlot(3,2,3,""); gr->Title("ColumnPlot");
gr->ColumnPlot(3, 0); gr->Box("r"); gr->Puts(mglPoint(0),"0","r");
gr->ColumnPlot(3, 1); gr->Box("g"); gr->Puts(mglPoint(0),"1","g");
gr->ColumnPlot(3, 2); gr->Box("b"); gr->Puts(mglPoint(0),"2","b");
gr->SubPlot(3,2,4,""); gr->Title("GridPlot");
gr->GridPlot(2, 2, 0); gr->Box("r"); gr->Puts(mglPoint(0),"0","r");
gr->GridPlot(2, 2, 1); gr->Box("g"); gr->Puts(mglPoint(0),"1","g");
gr->GridPlot(2, 2, 2); gr->Box("b"); gr->Puts(mglPoint(0),"2","b");
gr->GridPlot(2, 2, 3); gr->Box("m"); gr->Puts(mglPoint(0),"3","m");
gr->SubPlot(3,2,5,""); gr->Title("InPlot"); gr->Box();
gr->InPlot(0.4, 1, 0.6, 1, true); gr->Box("r");
gr->MultiPlot(3,2,1, 2, 1,""); gr->Title("MultiPlot and ShearPlot"); gr->Box();
gr->ShearPlot(3, 0, 0.2, 0.1); gr->Box("r"); gr->Puts(mglPoint(0),"0","r");
gr->ShearPlot(3, 1, 0.2, 0.1); gr->Box("g"); gr->Puts(mglPoint(0),"1","g");
gr->ShearPlot(3, 2, 0.2, 0.1); gr->Box("b"); gr->Puts(mglPoint(0),"2","b");
return 0;
}
Next: Curvilinear coordinates, Previous: Subplots, Up: Advanced usage [Contents][Index]
2.2.2 Axis and ticks
MathGL library can draw not only the bounding box but also the axes, grids, labels and so on. The ranges of axes and their origin (the point of intersection) are determined by functions SetRange(), SetRanges(), SetOrigin() (see Ranges (bounding box)). Ticks on axis are specified by function SetTicks, SetTicksVal, SetTicksTime (see Ticks). But usually
Function axis draws axes. Its textual string shows in which directions the axis or axes will be drawn (by default "xyz", function draws axes in all directions). Function grid draws grid perpendicularly to specified directions. Example of axes and grid drawing is:
int sample(mglGraph *gr)
{
gr->SubPlot(2,2,0); gr->Title("Axis origin, Grid"); gr->SetOrigin(0,0);
gr->Axis(); gr->Grid(); gr->FPlot("x^3");
gr->SubPlot(2,2,1); gr->Title("2 axis");
gr->SetRanges(-1,1,-1,1); gr->SetOrigin(-1,-1,-1); // first axis
gr->Axis(); gr->Label('y',"axis 1",0); gr->FPlot("sin(pi*x)");
gr->SetRanges(0,1,0,1); gr->SetOrigin(1,1,1); // second axis
gr->Axis(); gr->Label('y',"axis 2",0); gr->FPlot("cos(pi*x)");
gr->SubPlot(2,2,3); gr->Title("More axis");
gr->SetOrigin(NAN,NAN); gr->SetRange('x',-1,1);
gr->Axis(); gr->Label('x',"x",0); gr->Label('y',"y_1",0);
gr->FPlot("x^2","k");
gr->SetRanges(-1,1,-1,1); gr->SetOrigin(-1.3,-1); // second axis
gr->Axis("y","r"); gr->Label('y',"#r{y_2}",0.2);
gr->FPlot("x^3","r");
gr->SubPlot(2,2,2); gr->Title("4 segments, inverted axis");
gr->SetOrigin(0,0);
gr->InPlot(0.5,1,0.5,1); gr->SetRanges(0,10,0,2); gr->Axis();
gr->FPlot("sqrt(x/2)"); gr->Label('x',"W",1); gr->Label('y',"U",1);
gr->InPlot(0,0.5,0.5,1); gr->SetRanges(1,0,0,2); gr->Axis("x");
gr->FPlot("sqrt(x)+x^3"); gr->Label('x',"\\tau",-1);
gr->InPlot(0.5,1,0,0.5); gr->SetRanges(0,10,4,0); gr->Axis("y");
gr->FPlot("x/4"); gr->Label('y',"L",-1);
gr->InPlot(0,0.5,0,0.5); gr->SetRanges(1,0,4,0); gr->FPlot("4*x^2");
return 0;
}
Note, that MathGL can draw not only single axis (which is default). But also several axis on the plot (see right plots). The idea is that the change of settings does not influence on the already drawn graphics. So, for 2-axes I setup the first axis and draw everything concerning it. Then I setup the second axis and draw things for the second axis. Generally, the similar idea allows one to draw rather complicated plot of 4 axis with different ranges (see bottom left plot).
At this inverted axis can be created by 2 methods. First one is used in this sample – just specify minimal axis value to be large than maximal one. This method work well for 2D axis, but can wrongly place labels in 3D case. Second method is more general and work in 3D case too – just use aspect function with negative arguments. For example, following code will produce exactly the same result for 2D case, but 2nd variant will look better in 3D.
// variant 1 gr->SetRanges(0,10,4,0); gr->Axis(); // variant 2 gr->SetRanges(0,10,0,4); gr->Aspect(1,-1); gr->Axis();
Another MathGL feature is fine ticks tunning. By default (if it is not changed by SetTicks function), MathGL try to adjust ticks positioning, so that they looks most human readable. At this, MathGL try to extract common factor for too large or too small axis ranges, as well as for too narrow ranges. Last one is non-common notation and can be disabled by SetTuneTicks function.
Also, one can specify its own ticks with arbitrary labels by help of SetTicksVal function. Or one can set ticks in time format. In last case MathGL will try to select optimal format for labels with automatic switching between years, months/days, hours/minutes/seconds or microseconds. However, you can specify its own time representation using formats described in http://www.manpagez.com/man/3/strftime/. Most common variants are ‘%X’ for national representation of time, ‘%x’ for national representation of date, ‘%Y’ for year with century.
The sample code, demonstrated ticks feature is
int sample(mglGraph *gr)
{
gr->SubPlot(3,2,0); gr->Title("Usual axis"); gr->Axis();
gr->SubPlot(3,2,1); gr->Title("Too big/small range");
gr->SetRanges(-1000,1000,0,0.001); gr->Axis();
gr->SubPlot(3,2,3); gr->Title("Too narrow range");
gr->SetRanges(100,100.1,10,10.01); gr->Axis();
gr->SubPlot(3,2,4); gr->Title("Disable ticks tuning");
gr->SetTuneTicks(0); gr->Axis();
gr->SubPlot(3,2,2); gr->Title("Manual ticks"); gr->SetRanges(-M_PI,M_PI, 0, 2);
mreal val[]={-M_PI, -M_PI/2, 0, 0.886, M_PI/2, M_PI};
gr->SetTicksVal('x', mglData(6,val), "-\\pi\n-\\pi/2\n0\nx^*\n\\pi/2\n\\pi");
gr->Axis(); gr->Grid(); gr->FPlot("2*cos(x^2)^2", "r2");
gr->SubPlot(3,2,5); gr->Title("Time ticks"); gr->SetRange('x',0,3e5);
gr->SetTicksTime('x',0); gr->Axis();
return 0;
}
The last sample I want to show in this subsection is Log-axis. From MathGL’s point of view, the log-axis is particular case of general curvilinear coordinates. So, we need first define new coordinates (see also Curvilinear coordinates) by help of SetFunc or SetCoor functions. At this one should wary about proper axis range. So the code looks as following:
int sample(mglGraph *gr)
{
gr->SubPlot(2,2,0,"<_"); gr->Title("Semi-log axis");
gr->SetRanges(0.01,100,-1,1); gr->SetFunc("lg(x)","");
gr->Axis(); gr->Grid("xy","g"); gr->FPlot("sin(1/x)");
gr->Label('x',"x",0); gr->Label('y', "y = sin 1/x",0);
gr->SubPlot(2,2,1,"<_"); gr->Title("Log-log axis");
gr->SetRanges(0.01,100,0.1,100); gr->SetFunc("lg(x)","lg(y)");
gr->Axis(); gr->Grid("!","h="); gr->Grid();
gr->FPlot("sqrt(1+x^2)"); gr->Label('x',"x",0);
gr->Label('y', "y = \\sqrt{1+x^2}",0);
gr->SubPlot(2,2,2,"<_"); gr->Title("Minus-log axis");
gr->SetRanges(-100,-0.01,-100,-0.1); gr->SetFunc("-lg(-x)","-lg(-y)");
gr->Axis(); gr->FPlot("-sqrt(1+x^2)");
gr->Label('x',"x",0); gr->Label('y', "y = -\\sqrt{1+x^2}",0);
gr->SubPlot(2,2,3,"<_"); gr->Title("Log-ticks");
gr->SetRanges(0.1,100,0,100); gr->SetFunc("sqrt(x)","");
gr->Axis(); gr->FPlot("x");
gr->Label('x',"x",1); gr->Label('y', "y = x",0);
return 0;
}
You can see that MathGL automatically switch to log-ticks as we define log-axis formula (in difference from v.1.*). Moreover, it switch to log-ticks for any formula if axis range will be large enough (see right bottom plot). Another interesting feature is that you not necessary define usual log-axis (i.e. when coordinates are positive), but you can define “minus-log” axis when coordinate is negative (see left bottom plot).
Next: Colorbars, Previous: Axis and ticks, Up: Advanced usage [Contents][Index]
2.2.3 Curvilinear coordinates
As I noted in previous subsection, MathGL support curvilinear coordinates. In difference from other plotting programs and libraries, MathGL uses textual formulas for connection of the old (data) and new (output) coordinates. This allows one to plot in arbitrary coordinates. The following code plots the line y=0, z=0 in Cartesian, polar, parabolic and spiral coordinates:
int sample(mglGraph *gr)
{
gr->SetOrigin(-1,1,-1);
gr->SubPlot(2,2,0); gr->Title("Cartesian"); gr->Rotate(50,60);
gr->FPlot("2*t-1","0.5","0","r2");
gr->Axis(); gr->Grid();
gr->SetFunc("y*sin(pi*x)","y*cos(pi*x)",0);
gr->SubPlot(2,2,1); gr->Title("Cylindrical"); gr->Rotate(50,60);
gr->FPlot("2*t-1","0.5","0","r2");
gr->Axis(); gr->Grid();
gr->SetFunc("2*y*x","y*y - x*x",0);
gr->SubPlot(2,2,2); gr->Title("Parabolic"); gr->Rotate(50,60);
gr->FPlot("2*t-1","0.5","0","r2");
gr->Axis(); gr->Grid();
gr->SetFunc("y*sin(pi*x)","y*cos(pi*x)","x+z");
gr->SubPlot(2,2,3); gr->Title("Spiral"); gr->Rotate(50,60);
gr->FPlot("2*t-1","0.5","0","r2");
gr->Axis(); gr->Grid();
gr->SetFunc(0,0,0); // set to default Cartesian
return 0;
}
Next: Bounding box, Previous: Curvilinear coordinates, Up: Advanced usage [Contents][Index]
2.2.4 Colorbars
MathGL handle colorbar as special kind of axis. So, most of functions for axis and ticks setup will work for colorbar too. Colorbars can be in log-scale, and generally as arbitrary function scale; common factor of colorbar labels can be separated; and so on.
But of course, there are differences – colorbars usually located out of bounding box. At this, colorbars can be at subplot boundaries (by default), or at bounding box (if symbol ‘I’ is specified). Colorbars can handle sharp colors. And they can be located at arbitrary position too. The sample code, which demonstrate colorbar features is:
int sample(mglGraph *gr)
{
gr->SubPlot(2,2,0); gr->Title("Colorbar out of box"); gr->Box();
gr->Colorbar("<"); gr->Colorbar(">");
gr->Colorbar("_"); gr->Colorbar("^");
gr->SubPlot(2,2,1); gr->Title("Colorbar near box"); gr->Box();
gr->Colorbar("<I"); gr->Colorbar(">I");
gr->Colorbar("_I"); gr->Colorbar("^I");
gr->SubPlot(2,2,2); gr->Title("manual colors");
mglData a,v; mgls_prepare2d(&a,0,&v);
gr->Box(); gr->ContD(v,a);
gr->Colorbar(v,"<"); gr->Colorbar(v,">");
gr->Colorbar(v,"_"); gr->Colorbar(v,"^");
gr->SubPlot(2,2,3); gr->Title(" ");
gr->Puts(mglPoint(-0.5,1.55),"Color positions",":C",-2);
gr->Colorbar("bwr>",0.25,0); gr->Puts(mglPoint(-0.9,1.2),"Default");
gr->Colorbar("b{w,0.3}r>",0.5,0); gr->Puts(mglPoint(-0.1,1.2),"Manual");
gr->Puts(mglPoint(1,1.55),"log-scale",":C",-2);
gr->SetRange('c',0.01,1e3);
gr->Colorbar(">",0.75,0); gr->Puts(mglPoint(0.65,1.2),"Normal scale");
gr->SetFunc("","","","lg(c)");
gr->Colorbar(">"); gr->Puts(mglPoint(1.35,1.2),"Log scale");
return 0;
}
Next: Ternary axis, Previous: Colorbars, Up: Advanced usage [Contents][Index]
2.2.5 Bounding box
Box around the plot is rather useful thing because it allows one to: see the plot boundaries, and better estimate points position since box contain another set of ticks. MathGL provide special function for drawing such box – box function. By default, it draw black or white box with ticks (color depend on transparency type, see Types of transparency). However, you can change the color of box, or add drawing of rectangles at rear faces of box. Also you can disable ticks drawing, but I don’t know why anybody will want it. The sample code, which demonstrate box features is:
int sample(mglGraph *gr)
{
gr->SubPlot(2,2,0); gr->Title("Box (default)"); gr->Rotate(50,60);
gr->Box();
gr->SubPlot(2,2,1); gr->Title("colored"); gr->Rotate(50,60);
gr->Box("r");
gr->SubPlot(2,2,2); gr->Title("with faces"); gr->Rotate(50,60);
gr->Box("@");
gr->SubPlot(2,2,3); gr->Title("both"); gr->Rotate(50,60);
gr->Box("@cm");
return 0;
}
Next: Text features, Previous: Bounding box, Up: Advanced usage [Contents][Index]
2.2.6 Ternary axis
There are another unusual axis types which are supported by MathGL. These are ternary and quaternary axis. Ternary axis is special axis of 3 coordinates a, b, c which satisfy relation a+b+c=1. Correspondingly, quaternary axis is special axis of 4 coordinates a, b, c, d which satisfy relation a+b+c+d=1.
Generally speaking, only 2 of coordinates (3 for quaternary) are independent. So, MathGL just introduce some special transformation formulas which treat a as ‘x’, b as ‘y’ (and c as ‘z’ for quaternary). As result, all plotting functions (curves, surfaces, contours and so on) work as usual, but in new axis. You should use ternary function for switching to ternary/quaternary coordinates. The sample code is:
int sample(mglGraph *gr)
{
gr->SetRanges(0,1,0,1,0,1);
mglData x(50),y(50),z(50),rx(10),ry(10), a(20,30);
a.Modify("30*x*y*(1-x-y)^2*(x+y<1)");
x.Modify("0.25*(1+cos(2*pi*x))");
y.Modify("0.25*(1+sin(2*pi*x))");
rx.Modify("rnd"); ry.Modify("(1-v)*rnd",rx);
z.Modify("x");
gr->SubPlot(2,2,0); gr->Title("Ordinary axis 3D");
gr->Rotate(50,60); gr->Light(true);
gr->Plot(x,y,z,"r2"); gr->Surf(a,"BbcyrR#");
gr->Axis(); gr->Grid(); gr->Box();
gr->Label('x',"B",1); gr->Label('y',"C",1); gr->Label('z',"Z",1);
gr->SubPlot(2,2,1); gr->Title("Ternary axis (x+y+t=1)");
gr->Ternary(1);
gr->Plot(x,y,"r2"); gr->Plot(rx,ry,"q^ "); gr->Cont(a,"BbcyrR");
gr->Line(mglPoint(0.5,0), mglPoint(0,0.75), "g2");
gr->Axis(); gr->Grid("xyz","B;");
gr->Label('x',"B"); gr->Label('y',"C"); gr->Label('t',"A");
gr->SubPlot(2,2,2); gr->Title("Quaternary axis 3D");
gr->Rotate(50,60); gr->Light(true);
gr->Ternary(2);
gr->Plot(x,y,z,"r2"); gr->Surf(a,"BbcyrR#");
gr->Axis(); gr->Grid(); gr->Box();
gr->Label('t',"A",1); gr->Label('x',"B",1);
gr->Label('y',"C",1); gr->Label('z',"D",1);
gr->SubPlot(2,2,3); gr->Title("Ternary axis 3D");
gr->Rotate(50,60); gr->Light(true);
gr->Ternary(1);
gr->Plot(x,y,z,"r2"); gr->Surf(a,"BbcyrR#");
gr->Axis(); gr->Grid(); gr->Box();
gr->Label('t',"A",1); gr->Label('x',"B",1);
gr->Label('y',"C",1); gr->Label('z',"Z",1);
return 0;
}
Next: Legend sample, Previous: Ternary axis, Up: Advanced usage [Contents][Index]
2.2.7 Text features
MathGL prints text by vector font. There are functions for manual specifying of text position (like Puts) and for its automatic selection (like Label, Legend and so on). MathGL prints text always in specified position even if it lies outside the bounding box. The default size of font is specified by functions SetFontSize* (see Font settings). However, the actual size of output string depends on subplot size (depends on functions SubPlot, InPlot). The switching of the font style (italic, bold, wire and so on) can be done for the whole string (by function parameter) or inside the string. By default MathGL parses TeX-like commands for symbols and indexes (see Font styles).
Text can be printed as usual one (from left to right), along some direction (rotated text), or along a curve. Text can be printed on several lines, divided by new line symbol ‘\n’.
Example of MathGL font drawing is:
int sample(mglGraph *gr)
{
gr->SubPlot(2,2,0,"");
gr->Putsw(mglPoint(0,1),L"Text can be in ASCII and in Unicode");
gr->Puts(mglPoint(0,0.6),"It can be \\wire{wire}, \\big{big} or #r{colored}");
gr->Puts(mglPoint(0,0.2),"One can change style in string: "
"\\b{bold}, \\i{italic, \\b{both}}");
gr->Puts(mglPoint(0,-0.2),"Easy to \\a{overline} or "
"\\u{underline}");
gr->Puts(mglPoint(0,-0.6),"Easy to change indexes ^{up} _{down} @{center}");
gr->Puts(mglPoint(0,-1),"It parse TeX: \\int \\alpha \\cdot "
"\\sqrt3{sin(\\pi x)^2 + \\gamma_{i_k}} dx");
gr->SubPlot(2,2,1,"");
gr->Puts(mglPoint(0,0.5), "\\sqrt{\\frac{\\alpha^{\\gamma^2}+\\overset 1{\\big\\infty}}{\\sqrt3{2+b}}}", "@", -4);
gr->Puts(mglPoint(0,-0.5),"Text can be printed\non several lines");
gr->SubPlot(2,2,2,"");
mglData y; mgls_prepare1d(&y);
gr->Box(); gr->Plot(y.SubData(-1,0));
gr->Text(y,"This is very very long string drawn along a curve",":k");
gr->Text(y,"Another string drawn under a curve","T:r");
gr->SubPlot(2,2,3,"");
gr->Line(mglPoint(-1,-1),mglPoint(1,-1),"rA");
gr->Puts(mglPoint(0,-1),mglPoint(1,-1),"Horizontal");
gr->Line(mglPoint(-1,-1),mglPoint(1,1),"rA");
gr->Puts(mglPoint(0,0),mglPoint(1,1),"At angle","@");
gr->Line(mglPoint(-1,-1),mglPoint(-1,1),"rA");
gr->Puts(mglPoint(-1,0),mglPoint(-1,1),"Vertical");
return 0;
}
You can change font faces by loading font files by function loadfont. Note, that this is long-run procedure. Font faces can be downloaded from MathGL website or from here. The sample code is:
int sample(mglGraph *gr)
{
double h=1.1, d=0.25;
gr->LoadFont("STIX"); gr->Puts(mglPoint(0,h), "default font (STIX)");
gr->LoadFont("adventor"); gr->Puts(mglPoint(0,h-d), "adventor font");
gr->LoadFont("bonum"); gr->Puts(mglPoint(0,h-2*d), "bonum font");
gr->LoadFont("chorus"); gr->Puts(mglPoint(0,h-3*d), "chorus font");
gr->LoadFont("cursor"); gr->Puts(mglPoint(0,h-4*d), "cursor font");
gr->LoadFont("heros"); gr->Puts(mglPoint(0,h-5*d), "heros font");
gr->LoadFont("heroscn"); gr->Puts(mglPoint(0,h-6*d), "heroscn font");
gr->LoadFont("pagella"); gr->Puts(mglPoint(0,h-7*d), "pagella font");
gr->LoadFont("schola"); gr->Puts(mglPoint(0,h-8*d), "schola font");
gr->LoadFont("termes"); gr->Puts(mglPoint(0,h-9*d), "termes font");
return 0;
}
Next: Cutting sample, Previous: Text features, Up: Advanced usage [Contents][Index]
2.2.8 Legend sample
Legend is one of standard ways to show plot annotations. Basically you need to connect the plot style (line style, marker and color) with some text. In MathGL, you can do it by 2 methods: manually using addlegend function; or use ‘legend’ option (see Command options), which will use last plot style. In both cases, legend entries will be added into internal accumulator, which later used for legend drawing itself. clearlegend function allow you to remove all saved legend entries.
There are 2 features. If plot style is empty then text will be printed without indent. If you want to plot the text with indent but without plot sample then you need to use space ‘ ’ as plot style. Such style ‘ ’ will draw a plot sample (line with marker(s)) which is invisible line (i.e. nothing) and print the text with indent as usual one.
Function legend draw legend on the plot. The position of the legend can be selected automatic or manually. You can change the size and style of text labels, as well as setup the plot sample. The sample code demonstrating legend features is:
int sample(mglGraph *gr)
{
gr->AddLegend("sin(\\pi {x^2})","b");
gr->AddLegend("sin(\\pi x)","g*");
gr->AddLegend("sin(\\pi \\sqrt{x})","rd");
gr->AddLegend("just text"," ");
gr->AddLegend("no indent for this","");
gr->SubPlot(2,2,0,""); gr->Title("Legend (default)");
gr->Box(); gr->Legend();
gr->Legend(3,"A#");
gr->Puts(mglPoint(0.75,0.65),"Absolute position","A");
gr->SubPlot(2,2,2,""); gr->Title("coloring"); gr->Box();
gr->Legend(0,"r#"); gr->Legend(1,"Wb#"); gr->Legend(2,"ygr#");
gr->SubPlot(2,2,3,""); gr->Title("manual position"); gr->Box();
gr->Legend(0.5,1); gr->Puts(mglPoint(0.5,0.55),"at x=0.5, y=1","a");
gr->Legend(1,"#-"); gr->Puts(mglPoint(0.75,0.25),"Horizontal legend","a");
return 0;
}
Previous: Legend sample, Up: Advanced usage [Contents][Index]
2.2.9 Cutting sample
The last common thing which I want to show in this section is how one can cut off points from plot. There are 4 mechanism for that.
- You can set one of coordinate to NAN value. All points with NAN values will be omitted.
- You can enable cutting at edges by
SetCutfunction. As result all points out of bounding box will be omitted. - You can set cutting box by
SetCutBoxfunction. All points inside this box will be omitted. - You can define cutting formula by
SetCutOfffunction. All points for which the value of formula is nonzero will be omitted. Note, that this is the slowest variant.
Below I place the code which demonstrate last 3 possibilities:
int sample(mglGraph *gr)
{
mglData a,c,v(1); mgls_prepare2d(&a); mgls_prepare3d(&c); v.a[0]=0.5;
gr->SubPlot(2,2,0); gr->Title("Cut on (default)");
gr->Rotate(50,60); gr->Light(true);
gr->Box(); gr->Surf(a,"","zrange -1 0.5");
gr->SubPlot(2,2,1); gr->Title("Cut off"); gr->Rotate(50,60);
gr->Box(); gr->Surf(a,"","zrange -1 0.5; cut off");
gr->SubPlot(2,2,2); gr->Title("Cut in box"); gr->Rotate(50,60);
gr->SetCutBox(mglPoint(0,-1,-1), mglPoint(1,0,1.1));
gr->Alpha(true); gr->Box(); gr->Surf3(c);
gr->SetCutBox(mglPoint(0), mglPoint(0)); // switch it off
gr->SubPlot(2,2,3); gr->Title("Cut by formula"); gr->Rotate(50,60);
gr->CutOff("(z>(x+0.5*y-1)^2-1) & (z>(x-0.5*y-1)^2-1)");
gr->Box(); gr->Surf3(c); gr->CutOff(""); // switch it off
return 0;
}
Next: Data plotting, Previous: Advanced usage, Up: Examples [Contents][Index]
2.3 Data handling
Class mglData contains all functions for the data handling in MathGL (see Data processing). There are several matters why I use class mglData but not a single array: it does not depend on type of data (mreal or double), sizes of data arrays are kept with data, memory working is simpler and safer.
| • Array creation: | ||
| • Linking array: | ||
| • Change data: |
Next: Linking array, Up: Data handling [Contents][Index]
2.3.1 Array creation
There are many ways in MathGL how data arrays can be created and filled.
One can put the data in mglData instance by several ways. Let us do it for sinus function:
- one can create external array, fill it and put to
mglDatavariabledouble *a = new double[50]; for(int i=0;i<50;i++) a[i] = sin(M_PI*i/49.); mglData y; y.Set(a,50);
- another way is to create
mglDatainstance of the desired size and then to work directly with data in this variablemglData y(50); for(int i=0;i<50;i++) y.a[i] = sin(M_PI*i/49.);
- next way is to fill the data in
mglDatainstance by textual formula with the help ofModify()functionmglData y(50); y.Modify("sin(pi*x)"); - or one may fill the array in some interval and modify it later
mglData y(50); y.Fill(0,M_PI); y.Modify("sin(u)"); - finally it can be loaded from file
FILE *fp=fopen("sin.dat","wt"); // create file first for(int i=0;i<50;i++) fprintf(fp,"%g\n",sin(M_PI*i/49.)); fclose(fp); mglData y("sin.dat"); // load itAt this you can use textual or HDF files, as well as import values from bitmap image (PNG is supported right now).
- at this one can read only part of data
FILE *fp-fopen("sin.dat","wt"); // create large file first for(int i=0;i<70;i++) fprintf(fp,"%g\n",sin(M_PI*i/49.)); fclose(fp); mglData y; y.Read("sin.dat",50); // load it
Creation of 2d- and 3d-arrays is mostly the same. But one should keep in mind that class mglData uses flat data representation. For example, matrix 30*40 is presented as flat (1d-) array with length 30*40=1200 (nx=30, ny=40). The element with indexes {i,j} is a[i+nx*j]. So for 2d array we have:
mglData z(30,40);
for(int i=0;i<30;i++) for(int j=0;j<40;j++)
z.a[i+30*j] = sin(M_PI*i/29.)*sin(M_PI*j/39.);
or by using Modify() function
mglData z(30,40);
z.Modify("sin(pi*x)*cos(pi*y)");
The only non-obvious thing here is using multidimensional arrays in C/C++, i.e. arrays defined like mreal dat[40][30];. Since, formally these elements dat[i] can address the memory in arbitrary place you should use the proper function to convert such arrays to mglData object. For C++ this is functions like mglData::Set(mreal **dat, int N1, int N2);. For C this is functions like mgl_data_set_mreal2(HMDT d, const mreal **dat, int N1, int N2);. At this, you should keep in mind that nx=N2 and ny=N1 after conversion.
Next: Change data, Previous: Array creation, Up: Data handling [Contents][Index]
2.3.2 Linking array
Sometimes the data arrays are so large, that one couldn’t’ copy its values to another array (i.e. into mglData). In this case, he can define its own class derived from mglDataA (see mglDataA class) or can use Link function.
In last case, MathGL just save the link to an external data array, but not copy it. You should provide the existence of this data array for whole time during which MathGL can use it. Another point is that MathGL will automatically create new array if you’ll try to modify data values by any of mglData functions. So, you should use only function with const modifier if you want still using link to the original data array.
Creating the link is rather simple – just the same as using Set function
double *a = new double[50]; for(int i=0;i<50;i++) a[i] = sin(M_PI*i/49.); mglData y; y.Link(a,50);
Previous: Linking array, Up: Data handling [Contents][Index]
2.3.3 Change data
MathGL has functions for data processing: differentiating, integrating, smoothing and so on (for more detail, see Data processing). Let us consider some examples. The simplest ones are integration and differentiation. The direction in which operation will be performed is specified by textual string, which may contain symbols ‘x’, ‘y’ or ‘z’. For example, the call of Diff("x") will differentiate data along ‘x’ direction; the call of Integral("xy") perform the double integration of data along ‘x’ and ‘y’ directions; the call of Diff2("xyz") will apply 3d Laplace operator to data and so on. Example of this operations on 2d array a=x*y is presented in code:
int sample(mglGraph *gr)
{
gr->SetRanges(0,1,0,1,0,1);
mglData a(30,40); a.Modify("x*y");
gr->SubPlot(2,2,0); gr->Rotate(60,40);
gr->Surf(a); gr->Box();
gr->Puts(mglPoint(0.7,1,1.2),"a(x,y)");
gr->SubPlot(2,2,1); gr->Rotate(60,40);
a.Diff("x"); gr->Surf(a); gr->Box();
gr->Puts(mglPoint(0.7,1,1.2),"da/dx");
gr->SubPlot(2,2,2); gr->Rotate(60,40);
a.Integral("xy"); gr->Surf(a); gr->Box();
gr->Puts(mglPoint(0.7,1,1.2),"\\int da/dx dxdy");
gr->SubPlot(2,2,3); gr->Rotate(60,40);
a.Diff2("y"); gr->Surf(a); gr->Box();
gr->Puts(mglPoint(0.7,1,1.2),"\\int {d^2}a/dxdy dx");
return 0;
}
Data smoothing (function smooth) is more interesting and important. This function has single argument which define type of smoothing and its direction. Now 3 methods are supported: ‘3’ – linear averaging by 3 points, ‘5’ – linear averaging by 5 points, and default one – quadratic averaging by 5 points.
MathGL also have some amazing functions which is not so important for data processing as useful for data plotting. There are functions for finding envelope (useful for plotting rapidly oscillating data), for data sewing (useful to removing jumps on the phase), for data resizing (interpolation). Let me demonstrate it:
int sample(mglGraph *gr)
{
gr->SubPlot(2,2,0,""); gr->Title("Envelop sample");
mglData d1(1000); gr->Fill(d1,"exp(-8*x^2)*sin(10*pi*x)");
gr->Axis(); gr->Plot(d1, "b");
d1.Envelop('x'); gr->Plot(d1, "r");
gr->SubPlot(2,2,1,""); gr->Title("Smooth sample");
mglData y0(30),y1,y2,y3;
gr->SetRanges(0,1,0,1);
gr->Fill(y0, "0.4*sin(pi*x) + 0.3*cos(1.5*pi*x) - 0.4*sin(2*pi*x)+0.5*rnd");
y1=y0; y1.Smooth("x3");
y2=y0; y2.Smooth("x5");
y3=y0; y3.Smooth("x");
gr->Plot(y0,"{m7}:s", "legend 'none'"); //gr->AddLegend("none","k");
gr->Plot(y1,"r", "legend ''3' style'");
gr->Plot(y2,"g", "legend ''5' style'");
gr->Plot(y3,"b", "legend 'default'");
gr->Legend(); gr->Box();
gr->SubPlot(2,2,2); gr->Title("Sew sample");
mglData d2(100, 100); gr->Fill(d2, "mod((y^2-(1-x)^2)/2,0.1)");
gr->Rotate(50, 60); gr->Light(true); gr->Alpha(true);
gr->Box(); gr->Surf(d2, "b");
d2.Sew("xy", 0.1); gr->Surf(d2, "r");
gr->SubPlot(2,2,3); gr->Title("Resize sample (interpolation)");
mglData x0(10), v0(10), x1, v1;
gr->Fill(x0,"rnd"); gr->Fill(v0,"rnd");
x1 = x0.Resize(100); v1 = v0.Resize(100);
gr->Plot(x0,v0,"b+ "); gr->Plot(x1,v1,"r-");
gr->Label(x0,v0,"%n");
return 0;
}
Also one can create new data arrays on base of the existing one: extract slice, row or column of data (subdata), summarize along a direction(s) (sum), find distribution of data elements (hist) and so on.
Another interesting feature of MathGL is interpolation and root-finding. There are several functions for linear and cubic spline interpolation (see Interpolation). Also there is a function evaluate which do interpolation of data array for values of each data element of index data. It look as indirect access to the data elements.
This function have inverse function solve which find array of indexes at which data array is equal to given value (i.e. work as root finding). But solve function have the issue – usually multidimensional data (2d and 3d ones) have an infinite number of indexes which give some value. This is contour lines for 2d data, or isosurface(s) for 3d data. So, solve function will return index only in given direction, assuming that other index(es) are the same as equidistant index(es) of original data. If data have multiple roots then second (and later) branches can be found by consecutive call(s) of solve function. Let me demonstrate this on the following sample.
int sample(mglGraph *gr)
{
gr->SetRange('z',0,1);
mglData x(20,30), y(20,30), z(20,30), xx,yy,zz;
gr->Fill(x,"(x+2)/3*cos(pi*y)");
gr->Fill(y,"(x+2)/3*sin(pi*y)");
gr->Fill(z,"exp(-6*x^2-2*sin(pi*y)^2)");
gr->SubPlot(2,1,0); gr->Title("Cartesian space"); gr->Rotate(30,-40);
gr->Axis("xyzU"); gr->Box(); gr->Label('x',"x"); gr->Label('y',"y");
gr->SetOrigin(1,1); gr->Grid("xy");
gr->Mesh(x,y,z);
// section along 'x' direction
mglData u = x.Solve(0.5,'x');
mglData v(u.nx); v.Fill(0,1);
xx = x.Evaluate(u,v); yy = y.Evaluate(u,v); zz = z.Evaluate(u,v);
gr->Plot(xx,yy,zz,"k2o");
// 1st section along 'y' direction
mglData u1 = x.Solve(-0.5,'y');
mglData v1(u1.nx); v1.Fill(0,1);
xx = x.Evaluate(v1,u1); yy = y.Evaluate(v1,u1); zz = z.Evaluate(v1,u1);
gr->Plot(xx,yy,zz,"b2^");
// 2nd section along 'y' direction
mglData u2 = x.Solve(-0.5,'y',u1);
xx = x.Evaluate(v1,u2); yy = y.Evaluate(v1,u2); zz = z.Evaluate(v1,u2);
gr->Plot(xx,yy,zz,"r2v");
gr->SubPlot(2,1,1); gr->Title("Accompanied space");
gr->SetRanges(0,1,0,1); gr->SetOrigin(0,0);
gr->Axis(); gr->Box(); gr->Label('x',"i"); gr->Label('y',"j");
gr->Grid(z,"h");
gr->Plot(u,v,"k2o"); gr->Line(mglPoint(0.4,0.5),mglPoint(0.8,0.5),"kA");
gr->Plot(v1,u1,"b2^"); gr->Line(mglPoint(0.5,0.15),mglPoint(0.5,0.3),"bA");
gr->Plot(v1,u2,"r2v"); gr->Line(mglPoint(0.5,0.7),mglPoint(0.5,0.85),"rA");
}
Next: Hints, Previous: Data handling, Up: Examples [Contents][Index]
2.4 Data plotting
Let me now show how to plot the data. Next section will give much more examples for all plotting functions. Here I just show some basics. MathGL generally has 2 types of plotting functions. Simple variant requires a single data array for plotting, other data (coordinates) are considered uniformly distributed in axis range. Second variant requires data arrays for all coordinates. It allows one to plot rather complex multivalent curves and surfaces (in case of parametric dependencies). Usually each function have one textual argument for plot style and another textual argument for options (see Command options).
Note, that the call of drawing function adds something to picture but does not clear the previous plots (as it does in Matlab). Another difference from Matlab is that all setup (like transparency, lightning, axis borders and so on) must be specified before plotting functions.
Let start for plots for 1D data. Term “1D data” means that data depend on single index (parameter) like curve in parametric form {x(i),y(i),z(i)}, i=1...n. The textual argument allow you specify styles of line and marks (see Line styles). If this parameter is NULL or empty then solid line with color from palette is used (see Palette and colors).
Below I shall show the features of 1D plotting on base of plot function. Let us start from sinus plot:
int sample(mglGraph *gr)
{
mglData y0(50); y0.Modify("sin(pi*(2*x-1))");
gr->SubPlot(2,2,0);
gr->Plot(y0); gr->Box();
Style of line is not specified in plot function. So MathGL uses the solid line with first color of palette (this is blue). Next subplot shows array y1 with 2 rows:
gr->SubPlot(2,2,1);
mglData y1(50,2);
y1.Modify("sin(pi*2*x-pi)");
y1.Modify("cos(pi*2*x-pi)/2",1);
gr->Plot(y1); gr->Box();
As previously I did not specify the style of lines. As a result, MathGL again uses solid line with next colors in palette (there are green and red). Now let us plot a circle on the same subplot. The circle is parametric curve x=cos(\pi t), y=sin(\pi t). I will set the color of the circle (dark yellow, ‘Y’) and put marks ‘+’ at point position:
mglData x(50); x.Modify("cos(pi*2*x-pi)");
gr->Plot(x,y0,"Y+");
Note that solid line is used because I did not specify the type of line. The same picture can be achieved by plot and subdata functions. Let us draw ellipse by orange dash line:
gr->Plot(y1.SubData(-1,0),y1.SubData(-1,1),"q|");
Drawing in 3D space is mostly the same. Let us draw spiral with default line style. Now its color is 4-th color from palette (this is cyan):
gr->SubPlot(2,2,2); gr->Rotate(60,40);
mglData z(50); z.Modify("2*x-1");
gr->Plot(x,y0,z); gr->Box();
Functions plot and subdata make 3D curve plot but for single array. Use it to put circle marks on the previous plot:
mglData y2(10,3); y2.Modify("cos(pi*(2*x-1+y))");
y2.Modify("2*x-1",2);
gr->Plot(y2.SubData(-1,0),y2.SubData(-1,1),y2.SubData(-1,2),"bo ");
Note that line style is empty ‘ ’ here. Usage of other 1D plotting functions looks similar:
gr->SubPlot(2,2,3); gr->Rotate(60,40); gr->Bars(x,y0,z,"r"); gr->Box(); return 0; }
Surfaces surf and other 2D plots (see 2D plotting) are drown the same simpler as 1D one. The difference is that the string parameter specifies not the line style but the color scheme of the plot (see Color scheme). Here I draw attention on 4 most interesting color schemes. There is gray scheme where color is changed from black to white (string ‘kw’) or from white to black (string ‘wk’). Another scheme is useful for accentuation of negative (by blue color) and positive (by red color) regions on plot (string ‘"BbwrR"’). Last one is the popular “jet” scheme (string ‘"BbcyrR"’).
Now I shall show the example of a surface drawing. At first let us switch lightning on
int sample(mglGraph *gr)
{
gr->Light(true); gr->Light(0,mglPoint(0,0,1));
and draw the surface, considering coordinates x,y to be uniformly distributed in axis range
mglData a0(50,40);
a0.Modify("0.6*sin(2*pi*x)*sin(3*pi*y)+0.4*cos(3*pi*(x*y))");
gr->SubPlot(2,2,0); gr->Rotate(60,40);
gr->Surf(a0); gr->Box();
Color scheme was not specified. So previous color scheme is used. In this case it is default color scheme (“jet”) for the first plot. Next example is a sphere. The sphere is parametrically specified surface:
mglData x(50,40),y(50,40),z(50,40);
x.Modify("0.8*sin(2*pi*x)*sin(pi*y)");
y.Modify("0.8*cos(2*pi*x)*sin(pi*y)");
z.Modify("0.8*cos(pi*y)");
gr->SubPlot(2,2,1); gr->Rotate(60,40);
gr->Surf(x,y,z,"BbwrR");gr->Box();
I set color scheme to "BbwrR" that corresponds to red top and blue bottom of the sphere.
Surfaces will be plotted for each of slice of the data if nz>1. Next example draws surfaces for data arrays with nz=3:
mglData a1(50,40,3);
a1.Modify("0.6*sin(2*pi*x)*sin(3*pi*y)+0.4*cos(3*pi*(x*y))");
a1.Modify("0.6*cos(2*pi*x)*cos(3*pi*y)+0.4*sin(3*pi*(x*y))",1);
a1.Modify("0.6*cos(2*pi*x)*cos(3*pi*y)+0.4*cos(3*pi*(x*y))",2);
gr->SubPlot(2,2,2); gr->Rotate(60,40);
gr->Alpha(true);
gr->Surf(a1); gr->Box();
Note, that it may entail a confusion. However, if one will use density plot then the picture will look better:
gr->SubPlot(2,2,3); gr->Rotate(60,40); gr->Dens(a1); gr->Box(); return 0; }
Drawing of other 2D plots is analogous. The only peculiarity is the usage of flag ‘#’. By default this flag switches on the drawing of a grid on plot (grid or mesh for plots in plain or in volume). However, for isosurfaces (including surfaces of rotation axial) this flag switches the face drawing off. Figure becomes wired. The following code gives example of flag ‘#’ using (compare with normal function drawing as in its description):
int sample(mglGraph *gr)
{
gr->Alpha(true); gr->Light(true); gr->Light(0,mglPoint(0,0,1));
mglData a(30,20);
a.Modify("0.6*sin(2*pi*x)*sin(3*pi*y) + 0.4*cos(3*pi*(x*y))");
gr->SubPlot(2,2,0); gr->Rotate(40,60);
gr->Surf(a,"BbcyrR#"); gr->Box();
gr->SubPlot(2,2,1); gr->Rotate(40,60);
gr->Dens(a,"BbcyrR#"); gr->Box();
gr->SubPlot(2,2,2); gr->Rotate(40,60);
gr->Cont(a,"BbcyrR#"); gr->Box();
gr->SubPlot(2,2,3); gr->Rotate(40,60);
gr->Axial(a,"BbcyrR#"); gr->Box();
return 0;
}
Next: FAQ, Previous: Data plotting, Up: Examples [Contents][Index]
2.5 Hints
In this section I’ve included some small hints and advices for the improving of the quality of plots and for the demonstration of some non-trivial features of MathGL library. In contrast to previous examples I showed mostly the idea but not the whole drawing function.
Next: Transparency and lighting, Up: Hints [Contents][Index]
2.5.1 “Compound” graphics
As I noted above, MathGL functions (except the special one, like Clf()) do not erase the previous plotting but just add the new one. It allows one to draw “compound” plots easily. For example, popular Matlab command surfc can be emulated in MathGL by 2 calls:
Surf(a); Cont(a, "_"); // draw contours at bottom
Here a is 2-dimensional data for the plotting, -1 is the value of z-coordinate at which the contour should be plotted (at the bottom in this example). Analogously, one can draw density plot instead of contour lines and so on.
Another nice plot is contour lines plotted directly on the surface:
Light(true); // switch on light for the surface Surf(a, "BbcyrR"); // select 'jet' colormap for the surface Cont(a, "y"); // and yellow color for contours
The possible difficulties arise in black&white case, when the color of the surface can be close to the color of a contour line. In that case I may suggest the following code:
Light(true); // switch on light for the surface Surf(a, "kw"); // select 'gray' colormap for the surface CAxis(-1,0); // first draw for darker surface colors Cont(a, "w"); // white contours CAxis(0,1); // now draw for brighter surface colors Cont(a, "k"); // black contours CAxis(-1,1); // return color range to original state
The idea is to divide the color range on 2 parts (dark and bright) and to select the contrasting color for contour lines for each of part.
Similarly, one can plot flow thread over density plot of vector field amplitude (this is another amusing plot from Matlab) and so on. The list of compound graphics can be prolonged but I hope that the general idea is clear.
Just for illustration I put here following sample code:
int sample(mglGraph *gr)
{
mglData a,b,d; mgls_prepare2v(&a,&b); d = a;
for(int i=0;i<a.nx*a.ny;i++) d.a[i] = hypot(a.a[i],b.a[i]);
mglData c; mgls_prepare3d(&c);
mglData v(10); v.Fill(-0.5,1);
gr->SubPlot(2,2,1,""); gr->Title("Flow + Dens");
gr->Flow(a,b,"br"); gr->Dens(d,"BbcyrR"); gr->Box();
gr->SubPlot(2,2,0); gr->Title("Surf + Cont"); gr->Rotate(50,60);
gr->Light(true); gr->Surf(a); gr->Cont(a,"y"); gr->Box();
gr->SubPlot(2,2,2); gr->Title("Mesh + Cont"); gr->Rotate(50,60);
gr->Box(); gr->Mesh(a); gr->Cont(a,"_");
gr->SubPlot(2,2,3); gr->Title("Surf3 + ContF3");gr->Rotate(50,60);
gr->Box(); gr->ContF3(v,c,"z",0); gr->ContF3(v,c,"x"); gr->ContF3(v,c);
gr->SetCutBox(mglPoint(0,-1,-1), mglPoint(1,0,1.1));
gr->ContF3(v,c,"z",c.nz-1); gr->Surf3(-0.5,c);
return 0;
}
Next: Types of transparency, Previous: ``Compound'' graphics, Up: Hints [Contents][Index]
2.5.2 Transparency and lighting
Here I want to show how transparency and lighting both and separately change the look of a surface. So, there is code and picture for that:
int sample(mglGraph *gr)
{
mglData a; mgls_prepare2d(&a);
gr->SubPlot(2,2,0); gr->Title("default"); gr->Rotate(50,60);
gr->Box(); gr->Surf(a);
gr->SubPlot(2,2,1); gr->Title("light on"); gr->Rotate(50,60);
gr->Box(); gr->Light(true); gr->Surf(a);
gr->SubPlot(2,2,3); gr->Title("alpha on; light on"); gr->Rotate(50,60);
gr->Box(); gr->Alpha(true); gr->Surf(a);
gr->SubPlot(2,2,2); gr->Title("alpha on"); gr->Rotate(50,60);
gr->Box(); gr->Light(false); gr->Surf(a);
return 0;
}
Next: Axis projection, Previous: Transparency and lighting, Up: Hints [Contents][Index]
2.5.3 Types of transparency
MathGL library has advanced features for setting and handling the surface transparency. The simplest way to add transparency is the using of function alpha. As a result, all further surfaces (and isosurfaces, density plots and so on) become transparent. However, their look can be additionally improved.
The value of transparency can be different from surface to surface. To do it just use SetAlphaDef before the drawing of the surface, or use option alpha (see Command options). If its value is close to 0 then the surface becomes more and more transparent. Contrary, if its value is close to 1 then the surface becomes practically non-transparent.
Also you can change the way how the light goes through overlapped surfaces. The function SetTranspType defines it. By default the usual transparency is used (‘0’) – surfaces below is less visible than the upper ones. A “glass-like” transparency (‘1’) has a different look – each surface just decreases the background light (the surfaces are commutable in this case).
A “neon-like” transparency (‘2’) has more interesting look. In this case a surface is the light source (like a lamp on the dark background) and just adds some intensity to the color. At this, the library sets automatically the black color for the background and changes the default line color to white.
As example I shall show several plots for different types of transparency. The code is the same except the values of SetTranspType function:
int sample(mglGraph *gr)
{
gr->Alpha(true); gr->Light(true);
mglData a; mgls_prepare2d(&a);
gr->SetTranspType(0); gr->Clf();
gr->SubPlot(2,2,0); gr->Rotate(50,60); gr->Surf(a); gr->Box();
gr->SubPlot(2,2,1); gr->Rotate(50,60); gr->Dens(a); gr->Box();
gr->SubPlot(2,2,2); gr->Rotate(50,60); gr->Cont(a); gr->Box();
gr->SubPlot(2,2,3); gr->Rotate(50,60); gr->Axial(a); gr->Box();
return 0;
}
Next: Adding fog, Previous: Types of transparency, Up: Hints [Contents][Index]
2.5.4 Axis projection
You can easily make 3D plot and draw its x-,y-,z-projections (like in CAD) by using ternary function with arguments: 4 for Cartesian, 5 for Ternary and 6 for Quaternary coordinates. The sample code is:
int sample(mglGraph *gr)
{
gr->SetRanges(0,1,0,1,0,1);
mglData x(50),y(50),z(50),rx(10),ry(10), a(20,30);
a.Modify("30*x*y*(1-x-y)^2*(x+y<1)");
x.Modify("0.25*(1+cos(2*pi*x))");
y.Modify("0.25*(1+sin(2*pi*x))");
rx.Modify("rnd"); ry.Modify("(1-v)*rnd",rx);
z.Modify("x");
gr->Title("Projection sample");
gr->Ternary(4);
gr->Rotate(50,60); gr->Light(true);
gr->Plot(x,y,z,"r2"); gr->Surf(a,"#");
gr->Axis(); gr->Grid(); gr->Box();
gr->Label('x',"X",1); gr->Label('y',"Y",1); gr->Label('z',"Z",1);
}
Next: Lighting sample, Previous: Axis projection, Up: Hints [Contents][Index]
2.5.5 Adding fog
MathGL can add a fog to the image. Its switching on is rather simple – just use fog function. There is the only feature – fog is applied for whole image. Not to particular subplot. The sample code is:
int sample(mglGraph *gr)
{
mglData a; mgls_prepare2d(&a);
gr->Title("Fog sample");
gr->Light(true); gr->Rotate(50,60); gr->Fog(1); gr->Box();
gr->Surf(a); gr->Cont(a,"y");
return 0;
}
Next: Using primitives, Previous: Adding fog, Up: Hints [Contents][Index]
2.5.6 Lighting sample
In contrast to the most of other programs, MathGL supports several (up to 10) light sources. Moreover, the color each of them can be different: white (this is usual), yellow, red, cyan, green and so on. The use of several light sources may be interesting for the highlighting of some peculiarities of the plot or just to make an amusing picture. Note, each light source can be switched on/off individually. The sample code is:
int sample(mglGraph *gr)
{
mglData a; mgls_prepare2d(&a);
gr->Title("Several light sources");
gr->Rotate(50,60); gr->Light(true);
gr->AddLight(1,mglPoint(0,1,0),'c');
gr->AddLight(2,mglPoint(1,0,0),'y');
gr->AddLight(3,mglPoint(0,-1,0),'m');
gr->Box(); gr->Surf(a,"h");
return 0;
}
Additionally, you can use local light sources and set to use diffuse reflection instead of specular one (by default) or both kinds. Note, I use attachlight command to keep light settings relative to subplot.
int sample(mglGraph *gr)
{
gr->Light(true); gr->AttachLight(true);
gr->SubPlot(2,2,0); gr->Title("Default"); gr->Rotate(50,60);
gr->Line(mglPoint(-1,-0.7,1.7),mglPoint(-1,-0.7,0.7),"BA"); gr->Box(); gr->Surf(a);
gr->SubPlot(2,2,1); gr->Title("Local"); gr->Rotate(50,60);
gr->AddLight(0,mglPoint(1,0,1),mglPoint(-2,-1,-1));
gr->Line(mglPoint(1,0,1),mglPoint(-1,-1,0),"BAO"); gr->Box(); gr->Surf(a);
gr->SubPlot(2,2,2); gr->Title("no diffuse"); gr->Rotate(50,60);
gr->SetDiffuse(0);
gr->Line(mglPoint(1,0,1),mglPoint(-1,-1,0),"BAO"); gr->Box(); gr->Surf(a);
gr->SubPlot(2,2,3); gr->Title("diffusive only"); gr->Rotate(50,60);
gr->SetDiffuse(0.5);
gr->AddLight(0,mglPoint(1,0,1),mglPoint(-2,-1,-1),'w',0);
gr->Line(mglPoint(1,0,1),mglPoint(-1,-1,0),"BAO"); gr->Box(); gr->Surf(a);
}
Next: STFA sample, Previous: Lighting sample, Up: Hints [Contents][Index]
2.5.7 Using primitives
MathGL provide a set of functions for drawing primitives (see Primitives). Primitives are low level object, which used by most of plotting functions. Picture below demonstrate some of commonly used primitives.
Generally, you can create arbitrary new kind of plot using primitives. For example, MathGL don’t provide any special functions for drawing molecules. However, you can do it using only one type of primitives drop. The sample code is:
int sample(mglGraph *gr)
{
gr->Alpha(true); gr->Light(true);
gr->SubPlot(2,2,0,""); gr->Title("Methane, CH_4");
gr->StartGroup("Methane");
gr->Rotate(60,120);
gr->Sphere(mglPoint(0,0,0),0.25,"k");
gr->Drop(mglPoint(0,0,0),mglPoint(0,0,1),0.35,"h",1,2);
gr->Sphere(mglPoint(0,0,0.7),0.25,"g");
gr->Drop(mglPoint(0,0,0),mglPoint(-0.94,0,-0.33),0.35,"h",1,2);
gr->Sphere(mglPoint(-0.66,0,-0.23),0.25,"g");
gr->Drop(mglPoint(0,0,0),mglPoint(0.47,0.82,-0.33),0.35,"h",1,2);
gr->Sphere(mglPoint(0.33,0.57,-0.23),0.25,"g");
gr->Drop(mglPoint(0,0,0),mglPoint(0.47,-0.82,-0.33),0.35,"h",1,2);
gr->Sphere(mglPoint(0.33,-0.57,-0.23),0.25,"g");
gr->EndGroup();
gr->SubPlot(2,2,1,""); gr->Title("Water, H_{2}O");
gr->StartGroup("Water");
gr->Rotate(60,100);
gr->StartGroup("Water_O");
gr->Sphere(mglPoint(0,0,0),0.25,"r");
gr->EndGroup();
gr->StartGroup("Water_Bond_1");
gr->Drop(mglPoint(0,0,0),mglPoint(0.3,0.5,0),0.3,"m",1,2);
gr->EndGroup();
gr->StartGroup("Water_H_1");
gr->Sphere(mglPoint(0.3,0.5,0),0.25,"g");
gr->EndGroup();
gr->StartGroup("Water_Bond_2");
gr->Drop(mglPoint(0,0,0),mglPoint(0.3,-0.5,0),0.3,"m",1,2);
gr->EndGroup();
gr->StartGroup("Water_H_2");
gr->Sphere(mglPoint(0.3,-0.5,0),0.25,"g");
gr->EndGroup();
gr->EndGroup();
gr->SubPlot(2,2,2,""); gr->Title("Oxygen, O_2");
gr->StartGroup("Oxygen");
gr->Rotate(60,120);
gr->Drop(mglPoint(0,0.5,0),mglPoint(0,-0.3,0),0.3,"m",1,2);
gr->Sphere(mglPoint(0,0.5,0),0.25,"r");
gr->Drop(mglPoint(0,-0.5,0),mglPoint(0,0.3,0),0.3,"m",1,2);
gr->Sphere(mglPoint(0,-0.5,0),0.25,"r");
gr->EndGroup();
gr->SubPlot(2,2,3,""); gr->Title("Ammonia, NH_3");
gr->StartGroup("Ammonia");
gr->Rotate(60,120);
gr->Sphere(mglPoint(0,0,0),0.25,"b");
gr->Drop(mglPoint(0,0,0),mglPoint(0.33,0.57,0),0.32,"n",1,2);
gr->Sphere(mglPoint(0.33,0.57,0),0.25,"g");
gr->Drop(mglPoint(0,0,0),mglPoint(0.33,-0.57,0),0.32,"n",1,2);
gr->Sphere(mglPoint(0.33,-0.57,0),0.25,"g");
gr->Drop(mglPoint(0,0,0),mglPoint(-0.65,0,0),0.32,"n",1,2);
gr->Sphere(mglPoint(-0.65,0,0),0.25,"g");
gr->EndGroup();
return 0;
}
Moreover, some of special plots can be more easily produced by primitives rather than by specialized function. For example, Venn diagram can be produced by Error plot:
int sample(mglGraph *gr)
{
double xx[3]={-0.3,0,0.3}, yy[3]={0.3,-0.3,0.3}, ee[3]={0.7,0.7,0.7};
mglData x(3,xx), y(3,yy), e(3,ee);
gr->Title("Venn-like diagram"); gr->Alpha(true);
gr->Error(x,y,e,e,"!rgb@#o");
return 0;
}
You see that you have to specify and fill 3 data arrays. The same picture can be produced by just 3 calls of circle function:
int sample(mglGraph *gr)
{
gr->Title("Venn-like diagram"); gr->Alpha(true);
gr->Circle(mglPoint(-0.3,0.3),0.7,"rr@");
gr->Circle(mglPoint(0,-0.3),0.7,"gg@");
gr->Circle(mglPoint( 0.3,0.3),0.7,"bb@");
return 0;
}
Of course, the first variant is more suitable if you need to plot a lot of circles. But for few ones the usage of primitives looks easy.
Next: Mapping visualization, Previous: Using primitives, Up: Hints [Contents][Index]
2.5.8 STFA sample
Short-time Fourier Analysis (stfa) is one of informative method for analyzing long rapidly oscillating 1D data arrays. It is used to determine the sinusoidal frequency and phase content of local sections of a signal as it changes over time.
MathGL can find and draw STFA result. Just to show this feature I give following sample. Initial data arrays is 1D arrays with step-like frequency. Exactly this you can see at bottom on the STFA plot. The sample code is:
int sample(mglGraph *gr)
{
mglData a(2000), b(2000);
gr->Fill(a,"cos(50*pi*x)*(x<-.5)+cos(100*pi*x)*(x<0)*(x>-.5)+\
cos(200*pi*x)*(x<.5)*(x>0)+cos(400*pi*x)*(x>.5)");
gr->SubPlot(1, 2, 0,"<_"); gr->Title("Initial signal");
gr->Plot(a);
gr->Axis();
gr->Label('x', "\\i t");
gr->SubPlot(1, 2, 1,"<_"); gr->Title("STFA plot");
gr->STFA(a, b, 64);
gr->Axis();
gr->Label('x', "\\i t");
gr->Label('y', "\\omega", 0);
return 0;
}
Next: Data interpolation, Previous: STFA sample, Up: Hints [Contents][Index]
2.5.9 Mapping visualization
Sometime ago I worked with mapping and have a question about its visualization. Let me remember you that mapping is some transformation rule for one set of number to another one. The 1d mapping is just an ordinary function – it takes a number and transforms it to another one. The 2d mapping (which I used) is a pair of functions which take 2 numbers and transform them to another 2 ones. Except general plots (like surfc, surfa) there is a special plot – Arnold diagram. It shows the area which is the result of mapping of some initial area (usually square).
I tried to make such plot in map. It shows the set of points or set of faces, which final position is the result of mapping. At this, the color gives information about their initial position and the height describes Jacobian value of the transformation. Unfortunately, it looks good only for the simplest mapping but for the real multivalent quasi-chaotic mapping it produces a confusion. So, use it if you like :).
The sample code for mapping visualization is:
int sample(mglGraph *gr)
{
mglData a(50, 40), b(50, 40);
gr->Puts(mglPoint(0, 0), "\\to", ":C", -1.4);
gr->SetRanges(-1,1,-1,1,-2,2);
gr->SubPlot(2, 1, 0);
gr->Fill(a,"x"); gr->Fill(b,"y");
gr->Puts(mglPoint(0, 1.1), "\\{x, y\\}", ":C", -2); gr->Box();
gr->Map(a, b, "brgk");
gr->SubPlot(2, 1, 1);
gr->Fill(a,"(x^3+y^3)/2"); gr->Fill(b,"(x-y)/2");
gr->Puts(mglPoint(0, 1.1), "\\{\\frac{x^3+y^3}{2}, \\frac{x-y}{2}\\}", ":C", -2);
gr->Box();
gr->Map(a, b, "brgk");
return 0;
}
Next: Making regular data, Previous: Mapping visualization, Up: Hints [Contents][Index]
2.5.10 Data interpolation
There are many functions to get interpolated values of a data array. Basically all of them can be divided by 3 categories:
- functions which return single value at given point (see Interpolation and
mglGSpline()in Global functions); - functions subdata and evaluate for indirect access to data elements;
- functions refill, gspline and datagrid which fill regular (rectangular) data array by interpolated values.
The usage of first category is rather straightforward and don’t need any special comments.
There is difference in indirect access functions. Function subdata use use step-like interpolation to handle correctly single nan values in the data array. Contrary, function evaluate use local spline interpolation, which give smoother output but spread nan values. So, subdata should be used for specific data elements (for example, for given column), and evaluate should be used for distributed elements (i.e. consider data array as some field). Following sample illustrates this difference:
int sample(mglGraph *gr)
{
gr->SubPlot(1,1,0,""); gr->Title("SubData vs Evaluate");
mglData in(9), arg(99), e, s;
gr->Fill(in,"x^3/1.1"); gr->Fill(arg,"4*x+4");
gr->Plot(in,"ko "); gr->Box();
e = in.Evaluate(arg,false); gr->Plot(e,"b.","legend 'Evaluate'");
s = in.SubData(arg); gr->Plot(s,"r.","legend 'SubData'");
gr->Legend(2);
}
Example of datagrid usage is done in Making regular data. Here I want to show the peculiarities of refill and gspline functions. Both functions require argument(s) which provide coordinates of the data values, and return rectangular data array which equidistantly distributed in axis range. So, in opposite to evaluate function, refill and gspline can interpolate non-equidistantly distributed data. At this both functions refill and gspline provide continuity of 2nd derivatives along coordinate(s). However, refill is slower but give better (from human point of view) result than global spline gspline due to more advanced algorithm. Following sample illustrates this difference:
int sample(mglGraph *gr)
{
mglData x(10), y(10), r(100);
x.Modify("0.5+rnd"); x.CumSum("x"); x.Norm(-1,1);
y.Modify("sin(pi*v)/1.5",x);
gr->SubPlot(2,2,0,"<_"); gr->Title("Refill sample");
gr->Axis(); gr->Box(); gr->Plot(x,y,"o ");
gr->Refill(r,x,y); // or you can use r.Refill(x,y,-1,1);
gr->Plot(r,"r"); gr->FPlot("sin(pi*x)/1.5","B:");
gr->SubPlot(2,2,1,"<_");gr->Title("Global spline");
gr->Axis(); gr->Box(); gr->Plot(x,y,"o ");
r.RefillGS(x,y,-1,1); gr->Plot(r,"r");
gr->FPlot("sin(pi*x)/1.5","B:");
gr->Alpha(true); gr->Light(true);
mglData z(10,10), xx(10,10), yy(10,10), rr(100,100);
y.Modify("0.5+rnd"); y.CumSum("x"); y.Norm(-1,1);
for(int i=0;i<10;i++) for(int j=0;j<10;j++)
z.a[i+10*j] = sin(M_PI*x.a[i]*y.a[j])/1.5;
gr->SubPlot(2,2,2); gr->Title("2d regular"); gr->Rotate(40,60);
gr->Axis(); gr->Box(); gr->Mesh(x,y,z,"k");
gr->Refill(rr,x,y,z); gr->Surf(rr);
gr->Fill(xx,"(x+1)/2*cos(y*pi/2-1)");
gr->Fill(yy,"(x+1)/2*sin(y*pi/2-1)");
for(int i=0;i<10*10;i++)
z.a[i] = sin(M_PI*xx.a[i]*yy.a[i])/1.5;
gr->SubPlot(2,2,3); gr->Title("2d non-regular"); gr->Rotate(40,60);
gr->Axis(); gr->Box(); gr->Plot(xx,yy,z,"ko ");
gr->Refill(rr,xx,yy,z); gr->Surf(rr);
}
Next: Making histogram, Previous: Data interpolation, Up: Hints [Contents][Index]
2.5.11 Making regular data
Sometimes, one have only unregular data, like as data on triangular grids, or experimental results and so on. Such kind of data cannot be used as simple as regular data (like matrices). Only few functions, like dots, can handle unregular data as is.
However, one can use built in triangulation functions for interpolating unregular data points to a regular data grids. There are 2 ways. First way, one can use triangulation function to obtain list of vertexes for triangles. Later this list can be used in functions like triplot or tricont. Second way consist in usage of datagrid function, which fill regular data grid by interpolated values, assuming that coordinates of the data grid is equidistantly distributed in axis range. Note, you can use options (see Command options) to change default axis range as well as in other plotting functions.
int sample(mglGraph *gr)
{
mglData x(100), y(100), z(100);
gr->Fill(x,"2*rnd-1"); gr->Fill(y,"2*rnd-1"); gr->Fill(z,"v^2-w^2",x,y);
// first way - plot triangular surface for points
mglData d = mglTriangulation(x,y);
gr->Title("Triangulation");
gr->Rotate(40,60); gr->Box(); gr->Light(true);
gr->TriPlot(d,x,y,z); gr->TriPlot(d,x,y,z,"#k");
// second way - make regular data and plot it
mglData g(30,30);
gr->DataGrid(g,x,y,z); gr->Mesh(g,"m");
}
Next: Nonlinear fitting hints, Previous: Making regular data, Up: Hints [Contents][Index]
2.5.12 Making histogram
Using the hist function(s) for making regular distributions is one of useful fast methods to process and plot irregular data. Hist can be used to find some momentum of set of points by specifying weight function. It is possible to create not only 1D distributions but also 2D and 3D ones. Below I place the simplest sample code which demonstrate hist usage:
int sample(mglGraph *gr)
{
mglData x(10000), y(10000), z(10000); gr->Fill(x,"2*rnd-1");
gr->Fill(y,"2*rnd-1"); gr->Fill(z,"exp(-6*(v^2+w^2))",x,y);
mglData xx=gr->Hist(x,z), yy=gr->Hist(y,z); xx.Norm(0,1);
yy.Norm(0,1);
gr->MultiPlot(3,3,3,2,2,""); gr->SetRanges(-1,1,-1,1,0,1);
gr->Box(); gr->Dots(x,y,z,"wyrRk");
gr->MultiPlot(3,3,0,2,1,""); gr->SetRanges(-1,1,0,1);
gr->Box(); gr->Bars(xx);
gr->MultiPlot(3,3,5,1,2,""); gr->SetRanges(0,1,-1,1);
gr->Box(); gr->Barh(yy);
gr->SubPlot(3,3,2);
gr->Puts(mglPoint(0.5,0.5),"Hist and\nMultiPlot\nsample","a",-6);
return 0;
}
Next: PDE solving hints, Previous: Making histogram, Up: Hints [Contents][Index]
2.5.13 Nonlinear fitting hints
Nonlinear fitting is rather simple. All that you need is the data to fit, the approximation formula and the list of coefficients to fit (better with its initial guess values). Let me demonstrate it on the following simple example. First, let us use sin function with some random noise:
mglData dat(100), in(100); //data to be fitted and ideal data gr->Fill(dat,"0.4*rnd+0.1+sin(2*pi*x)"); gr->Fill(in,"0.3+sin(2*pi*x)");
and plot it to see that data we will fit
gr->Title("Fitting sample");
gr->SetRange('y',-2,2); gr->Box(); gr->Plot(dat, "k. ");
gr->Axis(); gr->Plot(in, "b");
gr->Puts(mglPoint(0, 2.2), "initial: y = 0.3+sin(2\\pi x)", "b");
The next step is the fitting itself. For that let me specify an initial values ini for coefficients ‘abc’ and do the fitting for approximation formula ‘a+b*sin(c*x)’
mreal ini[3] = {1,1,3};
mglData Ini(3,ini);
mglData res = gr->Fit(dat, "a+b*sin(c*x)", "abc", Ini);
Now display it
gr->Plot(res, "r"); gr->Puts(mglPoint(-0.9, -1.3), "fitted:", "r:L"); gr->PutsFit(mglPoint(0, -1.8), "y = ", "r");
NOTE! the fitting results may have strong dependence on initial values for coefficients due to algorithm features. The problem is that in general case there are several local "optimums" for coefficients and the program returns only first found one! There are no guaranties that it will be the best. Try for example to set ini[3] = {0, 0, 0} in the code above.
The full sample code for nonlinear fitting is:
int sample(mglGraph *gr)
{
mglData dat(100), in(100);
gr->Fill(dat,"0.4*rnd+0.1+sin(2*pi*x)");
gr->Fill(in,"0.3+sin(2*pi*x)");
mreal ini[3] = {1,1,3};
mglData Ini(3,ini);
mglData res = gr->Fit(dat, "a+b*sin(c*x)", "abc", Ini);
gr->Title("Fitting sample");
gr->SetRange('y',-2,2); gr->Box(); gr->Plot(dat, "k. ");
gr->Axis(); gr->Plot(res, "r"); gr->Plot(in, "b");
gr->Puts(mglPoint(-0.9, -1.3), "fitted:", "r:L");
gr->PutsFit(mglPoint(0, -1.8), "y = ", "r");
gr->Puts(mglPoint(0, 2.2), "initial: y = 0.3+sin(2\\pi x)", "b");
return 0;
}
Next: Drawing phase plain, Previous: Nonlinear fitting hints, Up: Hints [Contents][Index]
2.5.14 PDE solving hints
Solving of Partial Differential Equations (PDE, including beam tracing) and ray tracing (or finding particle trajectory) are more or less common task. So, MathGL have several functions for that. There are ray for ray tracing, pde for PDE solving, qo2d for beam tracing in 2D case (see Global functions). Note, that these functions take “Hamiltonian” or equations as string values. And I don’t plan now to allow one to use user-defined functions. There are 2 reasons: the complexity of corresponding interface; and the basic nature of used methods which are good for samples but may not good for serious scientific calculations.
The ray tracing can be done by ray function. Really ray tracing equation is Hamiltonian equation for 3D space. So, the function can be also used for finding a particle trajectory (i.e. solve Hamiltonian ODE) for 1D, 2D or 3D cases. The function have a set of arguments. First of all, it is Hamiltonian which defined the media (or the equation) you are planning to use. The Hamiltonian is defined by string which may depend on coordinates ‘x’, ‘y’, ‘z’, time ‘t’ (for particle dynamics) and momentums ‘p’=p_x, ‘q’=p_y, ‘v’=p_z. Next, you have to define the initial conditions for coordinates and momentums at ‘t’=0 and set the integrations step (default is 0.1) and its duration (default is 10). The Runge-Kutta method of 4-th order is used for integration.
const char *ham = "p^2+q^2-x-1+i*0.5*(y+x)*(y>-x)"; mglData r = mglRay(ham, mglPoint(-0.7, -1), mglPoint(0, 0.5), 0.02, 2);
This example calculate the reflection from linear layer (media with Hamiltonian ‘p^2+q^2-x-1’=p_x^2+p_y^2-x-1). This is parabolic curve. The resulting array have 7 columns which contain data for {x,y,z,p,q,v,t}.
The solution of PDE is a bit more complicated. As previous you have to specify the equation as pseudo-differential operator \hat H(x, \nabla) which is called sometime as “Hamiltonian” (for example, in beam tracing). As previously, it is defined by string which may depend on coordinates ‘x’, ‘y’, ‘z’ (but not time!), momentums ‘p’=(d/dx)/i k_0, ‘q’=(d/dy)/i k_0 and field amplitude ‘u’=|u|. The evolutionary coordinate is ‘z’ in all cases. So that, the equation look like du/dz = ik_0 H(x,y,\hat p, \hat q, |u|)[u]. Dependence on field amplitude ‘u’=|u| allows one to solve nonlinear problems too. For example, for nonlinear Shrodinger equation you may set ham="p^2 + q^2 - u^2". Also you may specify imaginary part for wave absorption, like ham = "p^2 + i*x*(x>0)" or ham = "p^2 + i1*x*(x>0)".
Next step is specifying the initial conditions at ‘z’ equal to minimal z-axis value. The function need 2 arrays for real and for imaginary part. Note, that coordinates x,y,z are supposed to be in specified axis range. So, the data arrays should have corresponding scales. Finally, you may set the integration step and parameter k0=k_0. Also keep in mind, that internally the 2 times large box is used (for suppressing numerical reflection from boundaries) and the equation should well defined even in this extended range.
Final comment is concerning the possible form of pseudo-differential operator H. At this moment, simplified form of operator H is supported – all “mixed” terms (like ‘x*p’->x*d/dx) are excluded. For example, in 2D case this operator is effectively H = f(p,z) + g(x,z,u). However commutable combinations (like ‘x*q’->x*d/dy) are allowed for 3D case.
So, for example let solve the equation for beam deflected from linear layer and absorbed later. The operator will have the form ‘"p^2+q^2-x-1+i*0.5*(z+x)*(z>-x)"’ that correspond to equation 1/ik_0 * du/dz + d^2 u/dx^2 + d^2 u/dy^2 + x * u + i (x+z)/2 * u = 0. This is typical equation for Electron Cyclotron (EC) absorption in magnetized plasmas. For initial conditions let me select the beam with plane phase front exp(-48*(x+0.7)^2). The corresponding code looks like this:
int sample(mglGraph *gr)
{
mglData a,re(128),im(128);
gr->Fill(re,"exp(-48*(x+0.7)^2)");
a = gr->PDE("p^2+q^2-x-1+i*0.5*(z+x)*(z>-x)", re, im, 0.01, 30);
a.Transpose("yxz");
gr->SubPlot(1,1,0,"<_"); gr->Title("PDE solver");
gr->SetRange('c',0,1); gr->Dens(a,"wyrRk");
gr->Axis(); gr->Label('x', "\\i x"); gr->Label('y', "\\i z");
gr->FPlot("-x", "k|");
gr->Puts(mglPoint(0, 0.85), "absorption: (x+z)/2 for x+z>0");
gr->Puts(mglPoint(0,1.1),"Equation: ik_0\\partial_zu + \\Delta u + x\\cdot u + i \\frac{x+z}{2}\\cdot u = 0");
return 0;
}
The next example is example of beam tracing. Beam tracing equation is special kind of PDE equation written in coordinates accompanied to a ray. Generally this is the same parameters and limitation as for PDE solving but the coordinates are defined by the ray and by parameter of grid width w in direction transverse the ray. So, you don’t need to specify the range of coordinates. BUT there is limitation. The accompanied coordinates are well defined only for smooth enough rays, i.e. then the ray curvature K (which is defined as 1/K^2 = (|r''|^2 |r'|^2 - (r'', r'')^2)/|r'|^6) is much large then the grid width: K>>w. So, you may receive incorrect results if this condition will be broken.
You may use following code for obtaining the same solution as in previous example:
int sample(mglGraph *gr)
{
mglData r, xx, yy, a, im(128), re(128);
const char *ham = "p^2+q^2-x-1+i*0.5*(y+x)*(y>-x)";
r = mglRay(ham, mglPoint(-0.7, -1), mglPoint(0, 0.5), 0.02, 2);
gr->SubPlot(1,1,0,"<_"); gr->Title("Beam and ray tracing");
gr->Plot(r.SubData(0), r.SubData(1), "k");
gr->Axis(); gr->Label('x', "\\i x"); gr->Label('y', "\\i z");
// now start beam tracing
gr->Fill(re,"exp(-48*x^2)");
a = mglQO2d(ham, re, im, r, xx, yy, 1, 30);
gr->SetRange('c',0, 1);
gr->Dens(xx, yy, a, "wyrRk");
gr->FPlot("-x", "k|");
gr->Puts(mglPoint(0, 0.85), "absorption: (x+y)/2 for x+y>0");
gr->Puts(mglPoint(0.7, -0.05), "central ray");
return 0;
}
Note, the pde is fast enough and suitable for many cases routine. However, there is situations then media have both together: strong spatial dispersion and spatial inhomogeneity. In this, case the pde will produce incorrect result and you need to use advanced PDE solver apde. For example, a wave beam, propagated in plasma, described by Hamiltonian exp(-x^2-p^2), will have different solution for using of simplification and advanced PDE solver:
int sample(mglGraph *gr)
{
gr->SetRanges(-1,1,0,2,0,2);
mglData ar(256), ai(256); gr->Fill(ar,"exp(-2*x^2)");
mglData res1(gr->APDE("exp(-x^2-p^2)",ar,ai,0.01)); res1.Transpose();
gr->SubPlot(1,2,0,"_"); gr->Title("Advanced PDE solver");
gr->SetRanges(0,2,-1,1); gr->SetRange('c',res1);
gr->Dens(res1); gr->Axis(); gr->Box();
gr->Label('x',"\\i z"); gr->Label('y',"\\i x");
gr->Puts(mglPoint(-0.5,0.2),"i\\partial_z\\i u = exp(-\\i x^2+\\partial_x^2)[\\i u]","y");
mglData res2(gr->PDE("exp(-x^2-p^2)",ar,ai,0.01));
gr->SubPlot(1,2,1,"_"); gr->Title("Simplified PDE solver");
gr->Dens(res2); gr->Axis(); gr->Box();
gr->Label('x',"\\i z"); gr->Label('y',"\\i x");
gr->Puts(mglPoint(-0.5,0.2),"i\\partial_z\\i u \\approx\\ exp(-\\i x^2)\\i u+exp(\\partial_x^2)[\\i u]","y");
return 0;
}
Next: Pulse properties, Previous: PDE solving hints, Up: Hints [Contents][Index]
2.5.15 Drawing phase plain
Here I want say a few words of plotting phase plains. Phase plain is name for system of coordinates x, x', i.e. a variable and its time derivative. Plot in phase plain is very useful for qualitative analysis of an ODE, because such plot is rude (it topologically the same for a range of ODE parameters). Most often the phase plain {x, x'} is used (due to its simplicity), that allows to analyze up to the 2nd order ODE (i.e. x''+f(x,x')=0).
The simplest way to draw phase plain in MathGL is using flow function(s), which automatically select several points and draw flow threads. If the ODE have an integral of motion (like Hamiltonian H(x,x')=const for dissipation-free case) then you can use cont function for plotting isolines (contours). In fact. isolines are the same as flow threads, but without arrows on it. Finally, you can directly solve ODE using ode function and plot its numerical solution.
Let demonstrate this for ODE equation x''-x+3*x^2=0. This is nonlinear oscillator with square nonlinearity. It has integral H=y^2+2*x^3-x^2=Const. Also it have 2 typical stationary points: saddle at {x=0, y=0} and center at {x=1/3, y=0}. Motion at vicinity of center is just simple oscillations, and is stable to small variation of parameters. In opposite, motion around saddle point is non-stable to small variation of parameters, and is very slow. So, calculation around saddle points are more difficult, but more important. Saddle points are responsible for solitons, stochasticity and so on.
So, let draw this phase plain by 3 different methods. First, draw isolines for H=y^2+2*x^3-x^2=Const – this is simplest for ODE without dissipation. Next, draw flow threads – this is straightforward way, but the automatic choice of starting points is not always optimal. Finally, use ode to check the above plots. At this we need to run ode in both direction of time (in future and in the past) to draw whole plain. Alternatively, one can put starting points far from (or at the bounding box as done in flow) the plot, but this is a more complicated. The sample code is:
int sample(mglGraph *gr)
{
gr->SubPlot(2,2,0,"<_"); gr->Title("Cont"); gr->Box();
gr->Axis(); gr->Label('x',"x"); gr->Label('y',"\\dot{x}");
mglData f(100,100); gr->Fill(f,"y^2+2*x^3-x^2-0.5");
gr->Cont(f);
gr->SubPlot(2,2,1,"<_"); gr->Title("Flow"); gr->Box();
gr->Axis(); gr->Label('x',"x"); gr->Label('y',"\\dot{x}");
mglData fx(100,100), fy(100,100);
gr->Fill(fx,"x-3*x^2"); gr->Fill(fy,"y");
gr->Flow(fy,fx,"v","value 7");
gr->SubPlot(2,2,2,"<_"); gr->Title("ODE"); gr->Box();
gr->Axis(); gr->Label('x',"x"); gr->Label('y',"\\dot{x}");
for(double x=-1;x<1;x+=0.1)
{
mglData in(2), r; in.a[0]=x;
r = mglODE("y;x-3*x^2","xy",in);
gr->Plot(r.SubData(0), r.SubData(1));
r = mglODE("-y;-x+3*x^2","xy",in);
gr->Plot(r.SubData(0), r.SubData(1));
}
}
Next: Using MGL parser, Previous: Drawing phase plain, Up: Hints [Contents][Index]
2.5.16 Pulse properties
There is common task in optics to determine properties of wave pulses or wave beams. MathGL provide special function pulse which return the pulse properties (maximal value, center of mass, width and so on). Its usage is rather simple. Here I just illustrate it on the example of Gaussian pulse, where all parameters are obvious.
void sample(mglGraph *gr)
{
gr->SubPlot(1,1,0,"<_"); gr->Title("Pulse sample");
// first prepare pulse itself
mglData a(100); gr->Fill(a,"exp(-6*x^2)");
// get pulse parameters
mglData b(a.Pulse('x'));
// positions and widths are normalized on the number of points. So, set proper axis scale.
gr->SetRanges(0, a.nx-1, 0, 1);
gr->Axis(); gr->Plot(a); // draw pulse and axis
// now visualize found pulse properties
double m = b[0]; // maximal amplitude
// approximate position of maximum
gr->Line(mglPoint(b[1],0), mglPoint(b[1],m),"r=");
// width at half-maximum (so called FWHM)
gr->Line(mglPoint(b[1]-b[3]/2,0), mglPoint(b[1]-b[3]/2,m),"m|");
gr->Line(mglPoint(b[1]+b[3]/2,0), mglPoint(b[1]+b[3]/2,m),"m|");
gr->Line(mglPoint(0,m/2), mglPoint(a.nx-1,m/2),"h");
// parabolic approximation near maximum
char func[128]; sprintf(func,"%g*(1-((x-%g)/%g)^2)",b[0],b[1],b[2]);
gr->FPlot(func,"g");
}
Next: Using options, Previous: Pulse properties, Up: Hints [Contents][Index]
2.5.17 Using MGL parser
Sometimes you may prefer to use MGL scripts in yours code. It is simpler (especially in comparison with C/Fortran interfaces) and provide faster way to plot the data with annotations, labels and so on. Class mglParse (see mglParse class parse MGL scripts in C++. It have also the corresponding interface for C/Fortran.
The key function here is mglParse::Parse() (or mgl_parse() for C/Fortran) which execute one command per string. At this the detailed information about the possible errors or warnings is passed as function value. Or you may execute the whole script as long string with lines separated by ‘\n’. Functions mglParse::Execute() and mgl_parse_text() perform it. Also you may set the values of parameters ‘$0’...‘$9’ for the script by functions mglParse::AddParam() or mgl_add_param(), allow/disable picture resizing, check “once” status and so on. The usage is rather straight-forward.
The only non-obvious thing is data transition between script and yours program. There are 2 stages: add or find variable; and set data to variable. In C++ you may use functions mglParse::AddVar() and mglParse::FindVar() which return pointer to mglData. In C/Fortran the corresponding functions are mgl_add_var(), mgl_find_var(). This data pointer is valid until next Parse() or Execute() call. Note, you must not delete or free the data obtained from these functions!
So, some simple example at the end. Here I define a data array, create variable, put data into it and plot it. The C++ code looks like this:
int sample(mglGraph *gr)
{
gr->Title("MGL parser sample");
mreal a[100]; // let a_i = sin(4*pi*x), x=0...1
for(int i=0;i<100;i++)a[i]=sin(4*M_PI*i/99);
mglParse *parser = new mglParse;
mglData *d = parser->AddVar("dat");
d->Set(a,100); // set data to variable
parser->Execute(gr, "plot dat; xrange 0 1\nbox\naxis");
// you may break script at any line do something
// and continue after that
parser->Execute(gr, "xlabel 'x'\nylabel 'y'\nbox");
// also you may use cycles or conditions in script
parser->Execute(gr, "for $0 -1 1 0.1\nline 0 0 -1 $0 'r'\nnext");
delete parser;
return 0;
}
The code in C/Fortran looks practically the same:
int sample(HMGL gr)
{
mgl_title(gr, "MGL parser sample", "", -2);
double a[100]; // let a_i = sin(4*pi*x), x=0...1
int i;
for(i=0;i<100;i++) a[i]=sin(4*M_PI*i/99);
HMPR parser = mgl_create_parser();
HMDT d = mgl_parser_add_var(parser, "dat");
mgl_data_set_double(d,a,100,1,1); // set data to variable
mgl_parse_text(gr, parser, "plot dat; xrange 0 1\nbox\naxis");
// you may break script at any line do something
// and continue after that
mgl_parse_text(gr, parser, "xlabel 'x'\nylabel 'y'");
// also you may use cycles or conditions in script
mgl_parse_text(gr, parser, "for $0 -1 1 0.1\nif $0<0\n"
"line 0 0 -1 $0 'r':else:line 0 0 -1 $0 'g'\n"
"endif\nnext");
mgl_write_png(gr, "test.png", ""); // don't forgot to save picture
return 0;
}
Next: ``Templates'', Previous: Using MGL parser, Up: Hints [Contents][Index]
2.5.18 Using options
Command options allow the easy setup of the selected plot by changing global settings only for this plot. Often, options are used for specifying the range of automatic variables (coordinates). However, options allows easily change plot transparency, numbers of line or faces to be drawn, or add legend entries. The sample function for options usage is:
void template(mglGraph *gr)
{
mglData a(31,41);
gr->Fill(a,"-pi*x*exp(-(y+1)^2-4*x^2)");
gr->SubPlot(2,2,0); gr->Title("Options for coordinates");
gr->Alpha(true); gr->Light(true);
gr->Rotate(40,60); gr->Box();
gr->Surf(a,"r","yrange 0 1"); gr->Surf(a,"b","yrange 0 -1");
if(mini) return;
gr->SubPlot(2,2,1); gr->Title("Option 'meshnum'");
gr->Rotate(40,60); gr->Box();
gr->Mesh(a,"r","yrange 0 1"); gr->Mesh(a,"b","yrange 0 -1; meshnum 5");
gr->SubPlot(2,2,2); gr->Title("Option 'alpha'");
gr->Rotate(40,60); gr->Box();
gr->Surf(a,"r","yrange 0 1; alpha 0.7");
gr->Surf(a,"b","yrange 0 -1; alpha 0.3");
gr->SubPlot(2,2,3,"<_"); gr->Title("Option 'legend'");
gr->FPlot("x^3","r","legend 'y = x^3'");
gr->FPlot("cos(pi*x)","b","legend 'y = cos \\pi x'");
gr->Box(); gr->Axis(); gr->Legend(2,"");
}
Next: Stereo image, Previous: Using options, Up: Hints [Contents][Index]
2.5.19 “Templates”
As I have noted before, the change of settings will influence only for the further plotting commands. This allows one to create “template” function which will contain settings and primitive drawing for often used plots. Correspondingly one may call this template-function for drawing simplification.
For example, let one has a set of points (experimental or numerical) and wants to compare it with theoretical law (for example, with exponent law \exp(-x/2), x \in [0, 20]). The template-function for this task is:
void template(mglGraph *gr)
{
mglData law(100); // create the law
law.Modify("exp(-10*x)");
gr->SetRanges(0,20, 0.0001,1);
gr->SetFunc(0,"lg(y)",0);
gr->Plot(law,"r2");
gr->Puts(mglPoint(10,0.2),"Theoretical law: e^x","r:L");
gr->Label('x',"x val."); gr->Label('y',"y val.");
gr->Axis(); gr->Grid("xy","g;"); gr->Box();
}
At this, one will only write a few lines for data drawing:
template(gr); // apply settings and default drawing from template
mglData dat("fname.dat"); // load the data
// and draw it (suppose that data file have 2 columns)
gr->Plot(dat.SubData(0),dat.SubData(1),"bx ");
A template-function can also contain settings for font, transparency, lightning, color scheme and so on.
I understand that this is obvious thing for any professional programmer, but I several times receive suggestion about “templates” ... So, I decide to point out it here.
Next: Reduce memory usage, Previous: ``Templates'', Up: Hints [Contents][Index]
2.5.20 Stereo image
One can easily create stereo image in MathGL. Stereo image can be produced by making two subplots with slightly different rotation angles. The corresponding code looks like this:
int sample(mglGraph *gr)
{
mglData a; mgls_prepare2d(&a);
gr->Light(true);
gr->SubPlot(2,1,0); gr->Rotate(50,60+1);
gr->Box(); gr->Surf(a);
gr->SubPlot(2,1,1); gr->Rotate(50,60-1);
gr->Box(); gr->Surf(a);
return 0;
}
Next: Saving and scanning file, Previous: Stereo image, Up: Hints [Contents][Index]
2.5.21 Reduce memory usage
By default MathGL save all primitives in memory, rearrange it and only later draw them on bitmaps. Usually, this speed up drawing, but may require a lot of memory for plots which contain a lot of faces (like cloud, dew). You can use quality function for setting to use direct drawing on bitmap and bypassing keeping any primitives in memory. This function also allow you to decrease the quality of the resulting image but increase the speed of the drawing.
The code for lowest memory usage looks like this:
int sample(mglGraph *gr)
{
gr->SetQuality(6); // firstly, set to draw directly on bitmap
for(i=0;i<1000;i++)
gr->Sphere(mglPoint(mgl_rnd()*2-1,mgl_rnd()*2-1),0.05);
return 0;
}
Next: Mixing bitmap and vector output, Previous: Reduce memory usage, Up: Hints [Contents][Index]
2.5.22 Scanning file
MathGL have possibilities to write textual information into file with variable values. In MGL script you can use save command for that. However, the usual printf(); is simple in C/C++ code. For example, lets create some textual file
FILE *fp=fopen("test.txt","w");
fprintf(fp,"This is test: 0 -> 1 q\n");
fprintf(fp,"This is test: 1 -> -1 q\n");
fprintf(fp,"This is test: 2 -> 0 q\n");
fclose(fp);
It contents look like
This is test: 0 -> 1 q This is test: 1 -> -1 q This is test: 2 -> 0 q
Let assume now that you want to read this values (i.e. [[0,1],[1,-1],[2,0]]) from the file. You can use scanfile for that. The desired values was written using template "This is test: %g -> %g q\n". So, just use
mglData a;
a.ScanFile("test.txt","This is test: %g -> %g");
and plot it to for assurance
gr->SetRanges(a.SubData(0), a.SubData(1)); gr->Axis(); gr->Plot(a.SubData(0),a.SubData(1),"o");
Note, I keep only the leading part of template (i.e. "This is test: %g -> %g" instead of "This is test: %g -> %g q\n"), because there is no important for us information after the second number in the line.
Previous: Saving and scanning file, Up: Hints [Contents][Index]
2.5.23 Mixing bitmap and vector output
Sometimes output plots contain surfaces with a lot of points, and some vector primitives (like axis, text, curves, etc.). Using vector output formats (like EPS or SVG) will produce huge files with possible loss of smoothed lighting. Contrary, the bitmap output may cause the roughness of text and curves. Hopefully, MathGL have a possibility to combine bitmap output for surfaces and vector one for other primitives in the same EPS file, by using rasterize command.
The idea is to prepare part of picture with surfaces or other "heavy" plots and produce the background image from them by help of rasterize command. Next, we draw everything to be saved in vector form (text, curves, axis and etc.). Note, that you need to clear primitives (use clf command) after rasterize if you want to disable duplication of surfaces in output files (like EPS). Note, that some of output formats (like 3D ones, and TeX) don’t support the background bitmap, and use clf for them will cause the loss of part of picture.
The sample code is:
// first draw everything to be in bitmap output
gr->FSurf("x^2+y^2", "#", "value 10");
gr->Rasterize(); // set above plots as bitmap background
gr->Clf(); // clear primitives, to exclude them from file
// now draw everything to be in vector output
gr->Axis(); gr->Box();
// and save file
gr->WriteFrame("fname.eps");
2.6 FAQ
- График не рисуется?!
Проверьте, что точки графика находятся внутри ограничивающего параллелепипеда, при необходимости увеличьте его с помощью функции
Axis(). Проверьте, что размерность массива правильная для выбранного типа графика. Убедитесь, что функцияFinish()была вызвана после построения графика (или график был сохранен в файл). Иногда отражение света от плоских поверхностей (типа,Dens()) может выглядеть как отсутствие графика.- Не нашел нужного графика?!
Многие “новые” графики можно строить, используя уже существующие функции. Например, поверхность вращения кривой относительно оси можно построить, используя специальную функцию
Torus(), а можно построить как параметрически заданную поверхностьSurf(). См. также Hints и Examples MathGL. Если же нужного типа графика все равно нет, то пишите мне e-mail и в следующей версии этот график появится.- Требуется ли знание сторонних библиотек (например, OpenGL) для использования библиотеки MathGL?
Нет. Библиотека MathGL самодостаточна и не требует знания сторонних библиотек.
- На каком языке написана библиотека? Для каких языков у нее есть интерфейсы?
Ядро библиотеки написано на С++. Кроме него, есть интерфейсы для чистого С, фортрана, паскаля, форта и собственный командный язык MGL. Также есть поддержка большого числа интерпретируемых языков (Python, Java, ALLEGROCL, CHICKEN, Lisp, CFFI, C#, Guile, Lua, Modula 3, Mzscheme, Ocaml, Octave, Perl, PHP, Pike, R, Ruby, Tcl). Эти интерфейсы написаны с помощью SWIG (и функции чистого С и классы). Однако на данный момент только интерфейсы для Python и Octave включены в скрипты сборки. Причина в том, что я не знаю других языков, чтобы проверить качество интерфейса :(. Замечу, что большинство прочих языков могут использовать С функции напрямую.
- Как мне использовать MathGL с Фортраном?
Библиотеку MathGL можно использовать как есть с компилятором
gfortranпоскольку он использует по умолчанию AT&T нотацию для внешних функций. Для других компиляторов (например, Visual Fortran) необходимо включить использование AT&T нотации вручную. AT&T нотация требует, чтобы имя функции завершалось символом ‘_’, аргументы функции передавались по указателю и длины строк передавались в конце списка аргументов. Например:C функция –
void mgl_fplot(HMGL graph, const char *fy, const char *stl, int n);AT&T функция –
void mgl_fplot_(uintptr_t *graph, const char *fy, const char *stl, int *n, int ly, int ls);При использовании фортрана необходимо также включить библиотеку
-lstdc++. Кроме того, если библиотека была собрана с опциейenable-double=ON(по умолчанию в версии 2.1 и более поздних), то все вещественные числа должны быть типаreal*8. Это можно включить по умолчанию опцией-fdefault-real-8.- У меня есть класс Foo и в нем метод рисования Foo::draw(mglGraph *gr). Как мне нарисовать что-то в окне FLTK, GLUT или Qt?
Функции-члены класса в С++ имеют “скрытый” параметр – указатель на экземпляр класса и их прямое использование невозможно. Решением будет определение интерфейсной функции:
int foo_draw(mglGraph *gr, void *par) { ((Foo *)foo)->draw(gr); }и подстановка именно ее в вызов функции
Window():gr->Window(argc,argv,foo_draw,"Title",this);
Можно также наследовать Ваш класс от класса
mglDrawи использовать функцию типаgr->Window(argc, argv, foo, "Title");.- Как мне вывести текст на русском/испанском/арабском/японском и т.д.?
Стандартный путь состоит в использовании кодировки UTF-8 для вывода текста. Кроме того, все функции вывода текста имеют интерфейс для 8-битных (char *) строк. Однако в последнем случае Вам может потребоваться установить используемую в исходном тексте локаль. Например, для русского языка в кодировке CP1251 можно использовать
setlocale(LC_CTYPE, "ru_RU.cp1251");(под MS Windows имена локали другие –setlocale(LC_CTYPE, "russian_russia.1251")). Настоятельно не рекомендую использовать константуLC_ALL, поскольку при этом меняется и формат чисел (в частности, десятичная точка), что может, например, вызвать сложности (неудобство) при написании формул и чтении текстовых файлов. Например, программа ожидает ‘,’ в качестве разделителя целой и дробной части, а пользователь вводит ‘.’.- Как мне вырезать (исключить из рисования) точку или область на графике?
Есть три основных способа. Во-первых, можно вырезать точку, задав одну из ее координат равной
NAN. Во-вторых, можно воспользоваться функциейSetCutBox()илиCutOff()для удаления точек из некоторой области (see Cutting). Наконец, можно сделать эти точки прозрачными (невидимыми) с помощью функцийSurfA(),Surf3A()(see Dual plotting). В последнем случае обеспечивается еще и плавность включения прозрачности.- Я использую VisualStudio, CBuilder или другой компилятор (не MinGW/gcc). Как мне подключить библиотеку MathGL?
Начиная с версии 2.0, рекомендуемый к использованию класс mglGraph (заголовочный файл
#include <mgl2/mgl.h>) содержbn только сinlineфункции и может использоваться с любым компилятором без перекомпиляции бинарной версии библиотеки. Однако, если Вы планируете использовать низкоуровневые возможности (т.е. классы mglBase, mglCanvas и т.д.), то Вам следует перекомпилировать библиотеку MathGL с использованием Вашего компилятора.Отмечу, что использование предоставляемых динамических библиотек *.dll требует создания библиотек импорта (import library *.lib). Эта процедура зависит от используемого компилятора – обратитесь к документации по Вашему компилятору. Например для VisualStudio это можно сделать командой
lib.exe /DEF:libmgl.def /OUT:libmgl.lib.- Как мне собрать MathGL под Windows?
Простейший путь – использование комбинации CMake и MinGW. Также Вам может потребоваться дополнительные библиотеки, такие как GSL, PNG, JPEG и пр. Все они могут быть найдены на http://gnuwin32.sourceforge.net/packages.html. После установки всех компонент, просто запустите конфигуратор CMake и соберите MathGL командой make.
- Как создать окно FLTK/GLUT/Qt с текущими результатами параллельно с выполнением основных вычислений?
Следует создать отдельный поток для обработки сообщений в окно. Обновление данных в окне можно выполнить вызовом функции
Update(). Подробнее см. Animation.- Сколько человек участвовало в создании библиотеки?
Большую часть библиотеки написал один человек. Это результат примерно года работы на написание ядра библиотеки и базовых функций (в основном вечерами и по выходным). Процесс усовершенствования продолжается и теперь :). Скрипты сборки в основном написаны Д.Кулагиным, а экспорт в PRC/PDF написан М.Видассовым.
- Как мне показать растровую картинку на рисунке?
Можно импортировать ее в экземпляр
mglDataи построить с помощью функцииDens(). Например, для черно-белого рисунка можно использовать код:mglData bmp; bmp.Import("fname.png","wk"); gr->Dens(bmp,"wk");.- Как использовать MathGL в Qt, FLTK, wxWidgets ...?
Есть специальные классы (виджеты) для этих библиотек: QMathGL для Qt, Fl_MathGL для FLTK и т.д. Если Вы не нашли подходящий класс, то можете создать свой собственный виджет, рисующий растровое изображение из mglCanvas::GetBits().
- Как мне создать 3D в PDF?
Используйте функцию
WritePRC(), которая создаст PDF файл если MathGL был собран с enable-pdf=ON.- Как мне создать TeX рисунок?
Используйте функцию
WriteTEX(), которая создаст LaTeX файлы с собственно рисунком ‘fname.tex’, с цветами MathGL ‘mglcolors.tex’ и основной файл ‘mglmain.tex’, который может использоваться для просмотра изображения и/или генерации PDF с помощью команды типаpdflatex mglmain.tex.- Можно ли использовать MathGL в JavaScript?
Да, пример JavaScript файла находится в папке texinfo/ исходных текстов. Для его работы необходимо предоставить JSON данные с 3d изображением (можно создать с помощью
WriteJSON() функции). Скрипт позволяет выполнять базовые операции: приближение/удаление, вращение и сдвиг. Примеры использования JavaScript можно найти в http://mathgl.sf.net/json.html.- Как сменить шрифт (семейство шрифтов)?
Во-первых, надо загрузить файлы отсюда или отсюда. Далее, в экземпляре mglGraph загружаем шрифты:
gr->LoadFont(fontname,path);. Здесь fontname – базовое имя шрифта, например ‘STIX’, и path – путь к папке с файлами шрифтов. Вызовитеgr->RestoreFont();для использования шрифта по умолчанию.- Как нарисовать метки оси снаружи от графика?
Просто используйте отрицательные значения длины меток, например
gr->SetTickLen(-0.1);.- Как нарисовать одинаковые оси координат для прямоугольного (не квадратного) рисунка?
Просто используйте
Aspect(NAN,NAN)для каждого подграфика, или в начале рисования.- Как задать полупрозрачный фон?
Просто используйте код типа
Clf("r{A5}");или подготовьте PNG файл и задайте его в качестве фона рисункаLoadBackground("fname.png");.- Как уменьшить поля вокруг графика?
Простейший путь состоит в использовании стилей subplot. Однако, вы должны быть осторожны в изменении стиля subplot если вы планируете добавлять colorbar или вращать график – часть графика может стать невидимой.
- Can I combine bitmap and vector output in EPS?
Yes. Sometimes you may have huge surface and a small set of curves and/or text on the plot. You can use function rasterize just after making surface plot. This will put all plot to bitmap background. At this later plotting will be in vector format. For example, you can do something like following:
gr->Surf(x, y, z); gr->Rasterize(); // make surface as bitmap gr->Axis(); gr->WriteFrame("fname.eps");- Почему у меня не получается использовать имя ‘I’ для переменной?
MathGL поддерживает стандарт C99, в котором имя ‘I’ зарезервированно для мнимой единицы. Если Вам все таки нужно это имя для переменной, то поместите
#undef I
сразу после включения заголовочных файлов MathGL.
- Как мне создать MPEG видео по графикам?
Вам следует сохранить каждый кадр в файл JPEG с именем типа ‘frame0001.jpg’, ‘frame0002.jpg’, ... Далее используйте ImageMagic для конвертации этих файлов в видео формата MPEG с помощью команды
convert frame*.jpg movie.mpg. См. также MPEG.
Next: MathGL core, Previous: Examples, Up: Top [Contents][Index]
3 Основные принципы
Возможности библиотеки MathGL довольно богаты – число только основных типов графиков превышает 50 видов. Кроме того, есть функции для обработки данных, настройки вида графика и пр. и пр. Тем не менее, я старался придерживаться единого стиля в порядке аргументов функций и способе их “настройки”. В основном все ниже сказанное относится к функциям рисования различных графиков.
Всего основных концепций (базисных идей) шесть:
- Все рисунки создаются в памяти. Это могут быть как растровые картинки (для
SetQuality(MGL_DRAW_LMEM)илиquality 6), так и векторные списки примитивов (по умолчанию). Дальнейшая судьба рисунков определяется пользователем: можно сохранить в файл, вывести на экран, создать анимацию/кино, дополнительно отредактировать и т.д. Такой подход обеспечивает высокую переносимость библиотеки – один и тот же программный код создаст в точности одинаковый рисунок на любой операционной системе. Кроме того, при таком подходе рисунки можно создавать непосредственно в консольной программе – графическое окно не нужно! - Все настройки графиков (стиль линий, цветовые схемы поверхностей, стиль и цвет текста) задаются строками. Это обеспечивает: удобство для пользователя – короткую строку легче читать и здесь тяжелее ошибиться, чем в большом списке параметров; переносимость – строки выглядят одинаково на всех платформах и не надо заботиться о типе и числе аргументов.
- Все функции имеют “упрощенный” и “продвинутый” варианты. Сделано опять из-за удобства. В “упрощенном” варианте для построения графика нужны только один-два массив(а) данных, которые автоматически равнораспределяются в заданном диапазоне осей координат. В “продвинутой” версии можно не только указать явно диапазон построения графика, но и задать его параметрически. Последнее позволяет легко строить довольно сложные кривые и поверхности. В обоих вариантах функций порядок аргументов стандартен: сначала идут массивы данных, потом необязательный строковый параметр стиля графика, а далее строка опций для более точной настройки графика.
- Все данные передаются через экземпляры класса mglData(A). Такой подход позволяет избежать ошибок при работе с памятью и единообразно передавать данные разных типов (float, double, данные из файла, заполненных пользователем и пр.) в функции рисования.
- Все элементы рисунков векторные. Изначально библиотека MathGL была ориентированна на работу с научными данными, которые по своей природе векторные (линии, грани, матрицы и т.д.). Поэтому векторность используется во всех рисунках! Причем иногда даже в ущерб производительности (например, при выводе шрифтов). Помимо всего прочего, векторность позволяет легко масштабировать рисунок – измените размер картинки в 2 раза, и рисунок пропорционально растянется.
- Новые графики не удаляют уже нарисованное. Этот, в чем-то неожиданный, подход позволяет создавать огромное количество “комбинированных” графиков. Например, поверхность с наложенными линиями уровня строится двумя последовательными вызовами функций рисования поверхности и линий уровня (в любом порядке). И совершенно не надо писать специальную функцию (как в Matlab и некоторых других программах) для рисования этого графика.
Кроме основных концепций я хотел бы остановиться на нескольких, как оказалось, нетривиальных моментах – способе указания положения графика, осей координат и строковых параметров линий, поверхностей, текста.
| • Coordinate axes: | ||
| • Color styles: | ||
| • Line styles: | ||
| • Color scheme: | ||
| • Font styles: | ||
| • Textual formulas: | ||
| • Command options: | ||
| • Interfaces: |
Next: Color styles, Up: General concepts [Contents][Index]
3.1 Оси координат
Представление системы координат в MathGL состоит из двух частей. Вначале координаты нормируются в диапазон изменения осей координат (see Axis settings). Если флаг SetCut() установлен, то точки вне интервала отбрасываются, в противном случае, они проецируются на ограничивающий параллелепипед (см. Cutting). Кроме того, отбрасываются точки внутри границ, определенных переменными CutMinxCutMax и точки, для которых значение функции CutOff() не равно нулю. После этого формулы перехода в криволинейную систему координат SetFunc()применяются к каждой точке. Наконец, точка данных отображается с помощью одной из графических функций.
Диапазон изменения x, y, z-координат задается функциями SetRange() или ranges. Точка пересечения осей координат задается функцией SetOrigin(). При этом можно использовать NAN значения для автоматического выбора положения оси.
Кроме привычных осей x, y, z есть еще одна ось – цветовая шкала – ось c. Она используется при окрашивании поверхностей и задает границы изменения функции при окрашивании. Ее границы автоматически устанавливаются равными диапазону z-оси при вызове ranges. Возможно и ручное изменение границ цветового интервала посредством вызова SetRange('c', ...). Используйте colorbar для отображения цветовой шкалы.
Вид меток по осям определяется функцией SetTicks() (see Ticks). Функция SetTuneTicks включает/выключает выделение общего множителя (большого или малого факторов в диапазоне) для меток осей координат. Наконец, если стандартный вид меток не устраивает пользователя, то их шаблон можно задать явно (можно использовать и ТеХ символы), воспользовавшись функцией SetTickTempl(). Кроме того, в качестве меток можно вывести произвольный текст использовав функцию SetTicksVal().
Next: Line styles, Previous: Coordinate axes, Up: General concepts [Contents][Index]
3.2 Цвета
Base colors are defined by one of symbol ‘wkrgbcymhRGBCYMHWlenupqLENUPQ’.
Символы цвета: ‘k’ – черный, ‘r’ – красный, ‘R’ – темно красный, ‘g’ – зеленый, ‘G’ – темно зеленый, ‘b’ – синий, ‘B’ – темно синий, ‘c’ – голубой, ‘C’ – темно голубой, ‘m’ – пурпурный, ‘M’ – темно пурпурный, ‘y’ – желтый, ‘Y’ – темно желтый (золотой), ‘h’ – серый, ‘H’ – темно серый, ‘w’ – белый, ‘W’ – светло серый, ‘l’ – сине-зеленый, ‘L’ – темно сине-зеленый, ‘e’ – желто-зеленый, ‘E’ – темно желто-зеленый, ‘n’ – небесно-синий, ‘N’ – темно небесно-синий, ‘u’ – сине-фиолетовый, ‘U’ – темно сине-фиолетовый, ‘p’ – фиолетовый, ‘P’ – темно фиолетовый, ‘q’ – оранжевый, ‘Q’ – темно оранжевый (коричневый).
В цветовой схеме можно использовать тональные (“подсвеченные”) цвета. Тональный цвет задается двумя символами в фигурных скобках ‘{cN}’: первый – обычный цвет, второй – его яркость цифрой. Цифра может быть в диапазоне ‘1’...‘9’. При этом ‘5’ соответствует нормальному цвету, ‘1’ – очень темная версия цвета (почти черный), ‘9’ – очень светлая версия цвета (почти белый). Например, цвета могут быть ‘{b2}’ ‘{b7}’ ‘{r7}’ и т.д.
Наконец, можно указать явно RGB или RGBA значения цвета, используя формат ‘{xRRGGBB}’ или ‘{xRRGGBBAA}’ соответственно. Например, ‘{xFF9966}’ даст цвет дыни.
Next: Color scheme, Previous: Color styles, Up: General concepts [Contents][Index]
3.3 Стиль линий
Стиль линии задается строкой, которая может содержать символ цвета (‘wkrgbcymhRGBCYMHWlenupqLENUPQ’), тип пунктира (‘-|;:ji’ или пробел), ширину линии (‘0123456789’) и тип маркера (‘o+xsd.^v’ и модификатор ‘#’). Если пропущен цвет или тип пунктира, то используется значение по умолчанию с последним указанным цветом или значение из палитры (для see 1D plotting). По умолчанию палитры содержит следующие цвета: темно серый ‘H’, синий ‘b’, зеленый ‘g’, красный ‘r’, голубой ‘c’, пурпурный ‘m’, yellow ‘y’, серый ‘h’, сине-зеленый ‘l’, небесно-синий ‘n’, оранжевый ‘q’, желто-зеленый ‘e’, сине-фиолетовый ‘u’, фиолетовый ‘p’.
Тип пунктира: пробел – нет линии (для рисования только маркеров), ‘-’ – сплошная линия (■■■■■■■■■■■■■■■■), ‘|’ – длинный пунктир (■■■■■■■■□□□□□□□□), ‘;’ – пунктир (■■■■□□□□■■■■□□□□), ‘=’ – короткий пунктир (■■□□■■□□■■□□■■□□), ‘:’ – точки (■□□□■□□□■□□□■□□□), ‘j’ – пунктир с точками (■■■■■■■□□□□■□□□□), ‘i’ – мелкий пунктир с точками (■■■□□■□□■■■□□■□□), ‘{dNNNN}’ – заданнÑй вÑÑÑнÑÑ ÑÑÐ¸Ð»Ñ (Ð´Ð»Ñ v.2.3 и Ð¿Ð¾Ð·Ð´Ð½Ð¸Ñ , напÑÐ¸Ð¼ÐµÑ ‘{df090}’ Ð´Ð»Ñ (■■■■□□□□■□□■□□□□)).
Типы маркеров: ‘o’ – окружность, ‘+’ – крест, ‘x’ – косой крест, ‘s’ – квадрат, ‘d’ - ромб, ‘.’ – точка, ‘^’ – треугольник вверх, ‘v’ – треугольник вниз, ‘<’ – треугольник влево, ‘>’ – треугольник вправо, ‘#*’ – знак Y, ‘#+’ – крест в квадрате, ‘#x’ – косой крест в квадрате, ‘#.’ – точка в окружности. Если в строке присутствует символ ‘#’, то используются символы с заполнением.
Вы можете определить собственные символы (см. addsymbol) для рисования маркеров при использовании стиля ‘&’. В частности, ‘&*’, ‘&o’, ‘&+’, ‘&x’, ‘&s’, ‘&d’, ‘&.’, ‘&^’, ‘&v’, ‘&<’, ‘&>’ нарисует определенный пользователем символ с именем ‘*o+xsd.^v<>’ соответственно; и
‘&#o’, ‘&#+’, ‘&#x’, ‘&#s’, ‘&#d’, ‘&#.’, ‘&#^’, ‘&#v’, ‘&#<’, ‘&#>’ нарисует определенный пользователем символ с именем ‘YOPXSDCTVLR’ соответственно. Замечу, что будет нарисован только контур определенного пользователем символа если задан отрицательный размер маркера (см. marksize или опцию size в Command options).
На конце и в начале линии можно выводить специальный символ (стрелку), если в строке указать один из символов: ‘A’ – стрелка наружу, ‘V’ – стрелка внутрь, ‘I’ – поперечная черта, ‘K’ – стрелка с чертой, ‘T’ – треугольник, ‘S’ – квадрат, ‘D’ – ромб, ‘O’ – круг, ‘X’ – косой крест, ‘_’ – нет стрелки (по умолчанию). При этом действует следующее правило: первый символ определяет стрелку на конце линии, второй символ – стрелку в начале линии. Например, ‘r-A’ – красная сплошная линия со стрелкой на конце, ‘b|AI’ – синий пунктир со стрелкой на конце и чертой вначале, ‘_O’ – линия с текущим стилем и кружком вначале. Эти стили действуют и при построении графиков (например, 1D plotting).
Next: Font styles, Previous: Line styles, Up: General concepts [Contents][Index]
3.4 Цветовая схема
Цветовая схема используется для определения цвета поверхностей, линий уровня и пр. Цветовая схема задается строкой s, которая содержит символы цвета (see Line styles) или символы ‘#:|’. Символ ‘#’ переключает рисование поверхности на сетчатое (для трехмерных поверхностей) или включает рисование сетки на поверхности. Символ ‘|’ отключает интерполяцию цвета в цветовой схеме. Это может быть полезно для “резких” цветов, например, при рисовании матриц. Если в строке встречается символ ‘:’, то он принудительно заканчивает разбор строки для стиля поверхности. После этого символа могут идти описание стиля текста или оси вращения кривой/линий уровня. Цветовая схема может содержать до 32 значений цвета.
При определении цвета по амплитуде (наиболее часто используется) окончательный цвет определяется путем линейной интерполяции массива цветов. Массив цветов формируется из цветов, указанных в строке спецификации. Аргумент – амплитуда, нормированная на диапазон изменения цвета (см. Axis settings). Например, строка из 4 символов ‘bcyr’ соответствует изменению цвета от синего (минимальное значение) через голубой и желтый (промежуточные значения) к красному (максимальное значение). Строка ‘kw’ соответствует изменению цвета от черного (минимальное значение) к белому (максимальное значение). Строка из одного символа (например, ‘g’) соответствует однотонному цвету (в данному случае зеленому).
Специальная двуосная цветовая схема (как в графике map) задается символом ‘%’. В ней второе направление (прозрачность) используется как вторая координата для цвета. При этом можно указать до 4 цветов для углов: {c1,a1}, {c2,a1}, {c1,a2}, {c2,a2}. Здесь диапазоны цвета и прозрачности равны {c1,c2} и {a1,a2}. Если указано меньше 4 цветов, то черный используется для угла {c1,a1}. Если задано только 2 цвета, то их сумма используется для угла {c2,a2}.
Есть несколько полезных цветовых схем. Строка ‘kw’ дает обычную серую (черно-белую) схему, когда большие значения светлее. Строка ‘wk’ представляет обратную серую схему, когда большие значения темнее. Строки ‘kRryw’, ‘kGgw’, ‘kBbcw’ представляют собой хорошо известные схемы hot, summer и winter. Строки ‘BbwrR’ и ‘bBkRr’ позволяют рисовать двухцветные фигуры на белом или черном фоне, когда отрицательные значения показаны синим цветом, а положительные – красным. Строка ‘BbcyrR’ дает цветовую схему, близкую к хорошо известной схеме jet.
Для более точно раскрашивания поверхностей можно изменить равномерное (по умолчанию) положение цветов в цветовой схеме. Формат следующий: ‘{CN,pos}’, ‘{CN,pos}’ или ‘{xRRGGBB,pos}’. Здесь значение pos положения цвета должно быть в диапазоне [0, 1]. Отмечу, что альтернативным механизмом тонкой настройки цветовой схемы может служить использование формул для цветовой координаты (см. Curved coordinates).
При определении цвета по положению точки в пространстве (используется в map) окончательный цвет определяется по формуле c=x*c[1] + y*c[2]. Здесь c[1], c[2] – первые три цвета в цветовом массиве; x, y – координаты точки, нормированные в диапазон изменения осей координат.
Дополнительно, MathGL может наложить маску при закраске граней для создания растрового изображения. Тип маски задается одним из символов ‘-+=;oOsS~<>jdD*^’ в цветовой схеме. Маску можно повернуть на произвольный угол командой mask или на один из улов +45, -45 или 90 градусов, используя символы ‘\/I’ соответственно. Примеры масок по умолчанию показаны на рисунке ниже.
Однако, вы можете задать собственную маску (как матрицу 8*8) для любого из этих символов, используя второй аргумент команды mask. Например, маска на правом нижнем подрисунке получается кодом
gr->SetMask('+', "ff00182424f80000"); gr->Dens(a,"3+");
или использовать явное задание маски (для v.2.3 и более поздних)
gr->Dens(a,"3{s00ff00182424f800}");
Next: Textual formulas, Previous: Color scheme, Up: General concepts [Contents][Index]
3.5 Стиль текста
Стиль текста задается строкой, которая может содержать цвет текста ‘wkrgbcymhRGBCYMHW’ (см. Color styles), а также тип шрифта (‘ribwou’) и/или выравнивания (‘LRC’) после символа ‘:’. Например, ‘r:iCb’ соответствует жирному (‘b’) курсиву (‘i’) с выравниванием по центру (‘C’ красного цвета (‘r’). Начиная с MathGL версии 2.3, вы можете использовать не только один цвет для всего текста, но и задать цветовой градиент для выводимой строки (см. Color scheme).
Начертания шрифта: ‘r’ – прямой шрифт, ‘i’ – курсив, ‘b’ – жирный. По умолчанию используется прямой шрифт. Типы выравнивания текста: ‘L’ – по левому краю (по умолчанию), ‘C’ – по центру, ‘R’ – по правому краю, ‘T’ – под текстом, ‘V’ – по центру вертикально. Дополнительные эффекты шрифта: ‘w’ – контурный, ‘o’ – надчеркнутый, ‘u’ – подчеркнутый.
Синтаксический разбор LaTeX-их команд по умолчанию включен. Это команды смены стиля текста (например, \b для жирного текста): \a или \overline – надчеркивание, \b или \textbf – жирный, \i или \textit – курсив, \r или \textrm – прямой (отменяет стили жирного и курсива), \u или \underline – подчеркнутый, \w или \wire – контурный, \big – большего размера, @ – меньшего размера. Нижний и верхний индексы задаются символами ‘_’ и ‘^’. При этом изменение стиля применяется только к следующему символу или к символам в фигурных скобках {}, которые понимаются как единый блок. Например, сравните строки ‘sin (x^{2^3})’ и ‘sin (x^2^3)’. Можно также менять цвет текста внутри строки с помощью команд #? или \color?, где ‘?’ – символ цвета (see Line styles). Например, слова ‘Blue’ и ‘red’ будут окрашены в соответствующий цвет в строке ‘#b{Blue} and \colorr{red} text’. Большинство функций понимает символ новой строки ‘\n’ и позволяет выводить много строчный текст. Наконец, можно использовать символы с произвольным UTF кодом с помощью команды \utf0x????. Например, \utf0x3b1 даст символ
α.
Распознаются также большинство символов TeX и AMSTeX, команды смены стиля текста (\textrm, \textbf, \textit, \textsc, \overline, \underline), акценты (\hat, \tilde, \dot, \ddot, \acute, \check, \grave, \bar, \breve) и корни (\sqrt, \sqrt3, \sqrt4). Полный список содержит около 2000 символов. Отмечу, что первый пробел (пробел, табуляция и пр.) после команды игнорируется, а все остальные пробелы печатаются обычным образом. Например, следующие строки дают одинаковый результат \tilde a: ‘\tilde{a}’; ‘\tilde a’; ‘\tilde{}a’.
В частности, распознаются греческие буквы: α – \alpha, β – \beta, γ – \gamma, δ – \delta, ε – \epsilon, η – \eta, ι – \iota, χ – \chi, κ – \kappa, λ – \lambda, μ – \mu, ν – \nu, o – \o, ω – \omega, ϕ – \phi, π – \pi, ψ – \psi, ρ – \rho, σ – \sigma, θ – \theta, τ – \tau, υ – \upsilon, ξ – \xi, ζ – \zeta, ς – \varsigma, ɛ – \varepsilon, ϑ – \vartheta, φ – \varphi, ϰ – \varkappa; A – \Alpha, B – \Beta, Γ – \Gamma, Δ – \Delta, E – \Epsilon, H – \Eta, I – \Iota, C – \Chi, K – \Kappa, Λ – \Lambda, M – \Mu, N – \Nu, O – \O, Ω – \Omega, Φ – \Phi, Π – \Pi, Ψ – \Psi, R – \Rho, Σ – \Sigma, Θ – \Theta, T – \Tau, Υ – \Upsilon, Ξ – \Xi, Z – \Zeta.Еще примеры наиболее общеупотребительных TeX-их символов: ∠ – \angle, ⋅ – \cdot, ♣ – \clubsuit, ✓ – \checkmark, ∪ – \cup, ∩ – \cap, ♢ – \diamondsuit, ◇ – \diamond, ÷ – \div, ↓ – \downarrow, † – \dag, ‡ – \ddag, ≡ – \equiv, ∃ – \exists, ⌢ – \frown, ♭ – \flat, ≥ – \ge, ≥ – \geq, ≧ – \geqq, ← – \gets, ♡ – \heartsuit, ∞ – \infty, ∫ – \int, \Int, ℑ – \Im, ♢ – \lozenge, ⟨ – \langle, ≤ – \le, ≤ – \leq, ≦ – \leqq, ← – \leftarrow, ∓ – \mp, ∇ – \nabla, ≠ – \ne, ≠ – \neq, ♮ – \natural, ∮ – \oint, ⊙ – \odot, ⊕ – \oplus, ∂ – \partial, ∥ – \parallel, ⊥ –\perp, ± – \pm, ∝ – \propto, ∏ – \prod, ℜ – \Re, → – \rightarrow, ⟩ – \rangle, ♠ – \spadesuit, ~ – \sim, ⌣ – \smile, ⊂ – \subset, ⊃ – \supset, √ – \sqrt or \surd, § – \S, ♯ – \sharp, ∑ – \sum, × – \times, → – \to, ∴ – \therefore, ↑ – \uparrow, ℘ – \wp.
Размер текста может быть задан явно (если size>0) или относительно базового размера шрифта для рисунка |size|*FontSize при size<0. Значение size=0 указывает, что соответствующая строка выводиться не будет. Базовый размер шрифта измеряется во внутренних единицах. Специальные функции SetFontSizePT(), SetFontSizeCM(), SetFontSizeIN() позволяют задавать его в более “привычных” единицах.
Next: Command options, Previous: Font styles, Up: General concepts [Contents][Index]
3.6 Текстовые формулы
MathGL имеет быстрый парсер текстовых формул (see Evaluate expression) , понимающий большое число функций и операций. Базовые операции: ‘+’ – сложение, ‘-’ – вычитание, ‘*’ – умножение, ‘/’ – деление, ‘%’ – остаток от деления, ‘^’ – возведение в целосичленную степень. Также есть логические операции: ‘<’ – истина если if x<y, ‘>’ – истина если x>y, ‘=’ – истина если x=y, ‘&’ – истина если x и y оба не равны нулю, ‘|’ – истина если x или y не нуль. Логические операции имеют наинизший приоритет и возвращают 1 если истина или 0 если ложно.
Базовые функции: ‘sqrt(x)’ – квадратный корень из x, ‘pow(x,y)’ – x в степени y, ‘ln(x)’ – натуральный логарифм x, ‘lg(x)’ – десятичный логарифм x, ‘log(a,x)’ – логарифм по основанию a от x, ‘abs(x)’ – модуль x, ‘sign(x)’ – знак x, ‘mod(x,y)’ – остаток от деления x на y, ‘step(x)’ – ступенчатая функция, ‘int(x)’ – целая часть x, ‘rnd’ – случайное число, ‘random(x)’ – матрица случайный чисел размером как x, ‘hypot(x,y)’=sqrt(x^2+y^2) – гипотенуза, ‘cmplx(x,y)’=x+i*y – комплексное число, ‘pi’ – число π = 3.1415926…, inf=∞
Функции для работы с комплексными числами ‘real(x)’, ‘imag(x)’, ‘abs(x)’, ‘arg(x)’, ‘conj(x)’.
Тригонометрические функции: ‘sin(x)’, ‘cos(x)’, ‘tan(x)’ (или ‘tg(x)’). Обратные тригонометрические функции: ‘asin(x)’, ‘acos(x)’, ‘atan(x)’. Гиперболические функции: ‘sinh(x)’ (или ‘sh(x)’), ‘cosh(x)’ (или ‘ch(x)’), ‘tanh(x)’ (или ‘th(x)’). Обратные гиперболические функции: ‘asinh(x)’, ‘acosh(x)’, ‘atanh(x)’.
Специальные функции: ‘gamma(x)’ – гамма функция Γ(x) = ∫0∞ tx-1 exp(-t) dt, ‘gamma_inc(x,y)’ – неполная гамма функция Γ(x,y) = ∫y∞ tx-1 exp(-t) dt, ‘psi(x)’ – дигамма функция ψ(x) = Γ′(x)/Γ(x) для x≠0, ‘ai(x)’ – Эйри функция Ai(x), ‘bi(x)’ – Эйри функция Bi(x), ‘cl(x)’ – функция Клаузена, ‘li2(x)’ (или ‘dilog(x)’) – дилогарифм Li2(x) = -ℜ∫0xds log(1-s)/s, ‘sinc(x)’ – функция sinc(x) = sin(πx)/(πx) для любых x, ‘zeta(x)’ – зета функция Римана ζ(s) = ∑k=1∞k-s для s≠1, ‘eta(x)’ – эта функция η(s) = (1 - 21-s)ζ(s) для произвольного s, ‘lp(l,x)’ – полином Лежандра Pl(x), (|x|≤1, l≥0), ‘w0(x)’, ‘w1(x)’ – функции Ламберта W. Функции W(x) определены как решение уравнения: W exp(W) = x.
Экспоненциальные интегралы: ‘ci(x)’ – cos-интеграл Ci(x) = ∫0xdt cos(t)/t, ‘si(x)’ – sin-интеграл Si(x) = ∫0xdt sin(t)/t, ‘erf(x)’ – функция ошибки erf(x) = (2/√π) ∫0xdt exp(-t2) , ‘ei(x)’ – интеграл Ei(x) = -PV(∫-x∞dt exp(-t)/t) (где PV обозначает главное значение), ‘e1(x)’ – интеграл E1(x) = ℜ∫1∞dt exp(-xt)/t, ‘e2(x)’ – интеграл E2(x) = ℜ∫1∞dt exp(-xt)/t2, ‘ei3(x)’ – интеграл Ei3(x) = ∫0xdt exp(-t3) для x≥0.
Функции Бесселя: ‘j(nu,x)’ – функция Бесселя первого рода, ‘y(nu,x)’ – функция Бесселя второго рода, ‘i(nu,x)’ – модифицированная функция Бесселя первого рода, ‘k(nu,x)’ – модифицированная функция Бесселя второго рода.
Эллиптические интегралы: ‘ee(k)’ – полный эллиптический интеграл E(k) = E(π/2,k), ‘ek(k)’ – полный эллиптический интеграл K(k) = F(π/2,k), ‘e(phi,k)’ – эллиптический интеграл E(φ,k) = ∫0φdt √(1 - k2sin2(t)), ‘f(phi,k)’ – эллиптический интеграл F(φ,k) = ∫0φdt 1/√(1 - k2sin2(t))
Функции Якоби: ‘sn(u,m)’, ‘cn(u,m)’, ‘dn(u,m)’, ‘sc(u,m)’, ‘sd(u,m)’, ‘ns(u,m)’, ‘cs(u,m)’, ‘cd(u,m)’, ‘nc(u,m)’, ‘ds(u,m)’, ‘dc(u,m)’, ‘nd(u,m)’.
Некоторые из функций могут быть недоступны если не была включена поддержка GSL при компиляции библиотеки MathGL.
При разборе формул нет различия между верхним и нижним регистром. Если аргумент лежит вне области определения функции, то возвращается NaN.
Next: Interfaces, Previous: Textual formulas, Up: General concepts [Contents][Index]
3.7 Опции команд
Опции команд позволяют легко настроить вид отдельного графика не меняя глобальных настроек для все рисунка. Каждая опция отделяется от предыдущей символом ‘;’. Опции работают так, что запоминают текущие настройки рисунка, применяют собственные настройки, выполняют команду и возвращают глобальные настройки обратно. Поэтому использование опций для команд обработки данных или настройки графика бесполезно.
Наиболее часто используемые опции – xrange, yrange, zrange, устанавливают границы изменения осей координат (и тем самым автоматических массивов). Например, команда Plot(y,"","xrange 0.1 0.9"); или plot y; xrange 0.1 0.9 построит кривую с x-координатой равно распределенной в интервале 0.1 ... 0.9, а не вдоль текущей оси x. См. раздел Using options, для примеров кода и графика.
- Опция MGL: alpha
val Задает величину прозрачности поверхности. Значение должно быть в диапазоне [0, 1]. См. также alphadef
- Опция MGL: xrange
val1 val2 Задает границы изменения координаты x. См. также xrange
- Опция MGL: yrange
val1 val2 Задает границы изменения координаты y. См. также yrange
- Опция MGL: zrange
val1 val2 Задает границы изменения координаты z. См. также zrange
- Опция MGL: cut
val Задает обрезание точек за пределами осей координат. См. также cut.
- Опция MGL: meshnum
val Задает ориентировочное число линий, стрелок, ячеек и пр. См. также meshnum
- Опция MGL: legend 'txt'
Добавляет строку ’txt’ во внутренний массив записей легенды. Стиль линии и маркера аргумента последней вызванной команды построения 1D plotting. См. также legend
- MGL option: value
val Задает значение, которое будет использовано как дополнительный числовой параметр при построении графика.
Previous: Command options, Up: General concepts [Contents][Index]
3.8 Интерфейсы
Библиотека MathGL имеет интерфейсы к ряду языков программирования. Большинство из них основано на С интерфейсе с использованием SWIG. Это Python, Java, Octave, Lisp, C#, Guile, Lua, Modula 3, Ocaml, Perl, PHP, Pike, R, Ruby, и Tcl интерфейсы. Также есть Fortran интерфейс, который имеет схожий набор функций, но слегка различающиеся типы аргументов (целые вместо указателей). Эти функции отмечены как [C function].
Некоторые языки поддерживают классы (подобно C++ или Python). Имена функций для них такие же как в С++ (см. MathGL core и Data processing) и отмечены, например, так [Method on mglGraph].
Наконец, специальный командный язык MGL (см. MGL scripts) был создан для быстрого доступа к функциям рисования. Соответствующие скрипты могут быть выполнены самостоятельно (с помощью UDAV, mglconv, mglview и т.д.) или из программы на языке C/C++/Python/... (см. mglParse class).
| • C interface: | ||
| • C++ interface: |
Next: C++ interface, Up: Interfaces [Contents][Index]
3.8.1 C/Fortran интерфейс
C интерфейс – основа для многих других интерфейсов. Он содержит функции С для всех методов MathGL. В отличие от C++ классов, C функции содержат обязательный(ые) аргумент(ы) типа HMGL (для графики) и/или HCDT/HMDT/HADT (для массивов данных), который указывают на объект для рисования или изменения. Поэтому перед использованием их необходимо создать с помощью функции mgl_create_*(), и удалить после использования (или в конце программы) с помощью функции mgl_delete_*().
Все C функции описаны в заголовочном файле #include <mgl2/mgl_cf.h> и используют переменные следующих типов:
-
HMGL— Указатель на классmglGraph(см. MathGL core). -
HCDT— Указатель на классconst mglDataA(см. Data processing) — неизменяемые массивы данных. -
HMDT— Указатель на классmglData(см. Data processing) — массивы данных с действительными числами. -
HADT— Указатель на классmglDataC(см. Data processing) — массивы данных с комплексными числами. -
HMPR— Указатель на классmglParse(см. mglParse class) — выполнение MGL скриптов. -
HMEX— Указатель на классmglExpr(см. Evaluate expression) — текстовые формулы для действительных чисел. -
HMAX— Указатель на классmglExprC(см. Evaluate expression) — текстовые формулы для комплексных чисел.
Фортрановские функции и подпрограммы имеют такие же имена как функции С. Однако есть отличие. Переменные типов HMGL, HCDT, HMDT, ... должны быть целыми с достаточной разрядностью (integer*4 для 32-битной операционной системы или integer*8 для 64-битной). Все C функции типа void — подпрограммы на Фортране и должны вызываться оператором call. Прочие функции, возвращающие тип HMGL или HMDT и т.п. должны быть объявлены в Фортране как возвращающие целое нужной разрядности. Также необходимо иметь в виду, что строки в Фортране отделяются символом ', а не ".
Previous: C interface, Up: Interfaces [Contents][Index]
3.8.2 C++/Python интерфейс
MathGL имеет интерфейс на основе классов (объектов с членами-функциями) с использованием библиотеки SWIG. Типичный пример – Python, имя которого использовано в заголовке раздела. В точности те же классы используются и в C++ API. Отмечу, что С++ классы содержат только inline члены-функции, что делает С++ API независимым от компилятора даже для бинарной версии.
Есть 3 основных класса:
-
mglGraph– обеспечивает вывод графики (см. MathGL core). -
mglData– обеспечивает обработку данных (см. Data processing). Класс имеет возможность прямого доступа к данным с помощью конструкции вида:dat[i]=sth;илиsth=dat[i], где используется "плоское" представление данных (т.е., i может быть в диапазоне 0...nx*nx*nz-1). Также можно импортировать массивы NumPy в Python:mgl_dat = mglData(numpy_dat);. -
mglParse– обеспечивает выполнение скриптов MGL (см. MGL scripts).
Для использования в Python достаточно выполнить ‘import mathgl’. Простейший пример имеет вид:
import mathgl
a=mathgl.mglGraph()
a.Box()
a.WritePNG("test.png")
Также можно импортировать все классы из модуля mathgl и обеспечить более легкий доступ к MathGL:
from mathgl import *
a=mglGraph()
a.Box()
a.WritePNG("test.png")
Это становится более полезным если, например, вы создаете много объектов данных mglData.
Next: Widget classes, Previous: General concepts, Up: Top [Contents][Index]
4 Ядро MathGL
Основным классом MathGL является класс mglGraph, определённый в #include <mgl2/mgl.h>. Он включает в себя множество функций для построения графиков от 1D, 2D и 3D массивов. Он также содержит функции вывода текста и построения осей координат. Есть возможность построения в произвольной системе координат, которая задается строковыми формулами. Все графические функции используют класс mglData (см. Data processing) для хранения массивов данных. Это позволяет легко контролировать размеры, работу с памятью и производить обработку данных. Дополнительная информация о цветах, шрифтах, вычисления формул может быть найдена в General concepts и Other classes.
Некоторые возможности MathGL доступны только в новых версиях библиотеки. Для проверки текущей версии MathGL можно использовать следующую функцию.
- Команда MGL: version 'ver'
- Метод класса
mglGraph:boolCheckVersion (const char *ver) static - Функция С:
intmgl_check_version (const char *ver) Возвращает нулевое значение если версия MathGL подходит для требуемой в ver, т.е. если номер основной версии совпадает и "подверсия" больше или равна указанной в ver.
| • Constructor: | ||
| • Graphics setup: | ||
| • Axis settings: | ||
| • Subplots and rotation: | ||
| • Export picture: | ||
| • Background: | ||
| • Primitives: | ||
| • Text printing: | ||
| • Axis and Colorbar: | ||
| • Legend: | ||
| • 1D plotting: | ||
| • 2D plotting: | ||
| • 3D plotting: | ||
| • Dual plotting: | ||
| • Vector fields: | ||
| • Other plotting: | ||
| • Nonlinear fitting: | ||
| • Data manipulation: |
Next: Graphics setup, Up: MathGL core [Contents][Index]
4.1 Создание и удаление графического объекта
- Конструктор класса
mglGraph: mglGraph (intkind=0,intwidth=600,intheight=400) - Конструктор класса
mglGraph: mglGraph (const mglGraph &gr) - Конструктор класса
mglGraph: mglGraph (HMGLgr) - Функция С:
HMGLmgl_create_graph (intwidth,intheight) - Функция С:
HMGLmgl_create_graph_gl () Создает (или использует созданный) экземпляр класса, производного от
mglGraph(типHMGL) с указанными размерами width и height. Параметр kind может иметь следующие значения: ‘0’ – использовать рисование по умолчанию, ‘1’ – использовать рисование в OpenGL.
- Destructor on
mglGraph: ~mglGraph () - Функция С:
HMGLmgl_delete_graph (HMGLgr) Удаляет экземпляр класса mglGraph.
Next: Axis settings, Previous: Constructor, Up: MathGL core [Contents][Index]
4.2 Настройка графика
Функции и переменные в этой группе влияют на вид всего рисунка. Соответственно они должны располагаться перед вызовом функций непосредственно рисующих графики.
- Команда MGL: reset
- Метод класса
mglGraph:voidDefaultPlotParam () - Функция С:
voidmgl_set_def_param (HMGLgr) Устанавливает все настройки по умолчанию и очищает рисунок.
- Команда MGL: setup
val flag - Метод класса
mglGraph:voidSetFlagAdv (intval,uint32_tflag) - Функция С:
voidmgl_set_flag (HMGLgr,intval,uint32_tflag) Устанавливает значение бинарного флага flag в val. Список флагов можно найти в define.h. Текущий список флагов:
#define MGL_ENABLE_CUT 0x00000004 ///< Определяет способ рисования точек вне диапазона осей координат #define MGL_ENABLE_RTEXT 0x00000008 ///< Использовать вращение текста #define MGL_AUTO_FACTOR 0x00000010 ///< Разрешить автоматическое масштабирование графика #define MGL_ENABLE_ALPHA 0x00000020 ///< Использовать прозрачность #define MGL_ENABLE_LIGHT 0x00000040 ///< Использовать освещение #define MGL_TICKS_ROTATE 0x00000080 ///< Разрешить вращение меток осей #define MGL_TICKS_SKIP 0x00000100 ///< Разрешить пропуск меток осей #define MGL_DISABLE_SCALE 0x00000200 ///< Временный флаг, запрещающий изменение размеров #define MGL_FINISHED 0x00000400 ///< Флаг готовности окончательной картинки (т.е. mglCanvas::G) #define MGL_USE_GMTIME 0x00000800 ///< Использовать gmtime вместо localtime #define MGL_SHOW_POS 0x00001000 ///< Включить показ координат щелчка мыши #define MGL_CLF_ON_UPD 0x00002000 ///< Очищать график перед Update() #define MGL_NOSUBTICKS 0x00004000 ///< Запретить рисование subticks для bounding box #define MGL_LOCAL_LIGHT 0x00008000 ///< Сохранять источники освещения в каждом inplot #define MGL_VECT_FRAME 0x00010000 ///< Использовать DrwDat для сохранения всех данных в кадрах #define MGL_REDUCEACC 0x00020000 ///< Сокращать точность вывода точек (для уменьшения размера выходных файлов) #define MGL_PREFERVC 0x00040000 ///< Предпочитать цвета вершин вместо текстур если выходной формат поддерживает #define MGL_ONESIDED 0x00080000 ///< Выводить только переднюю сторону поверхностей если выходной формат поддерживает #define MGL_NO_ORIGIN 0x00100000 ///< Не рисовать метки в точке пересечения осей #define MGL_GRAY_MODE 0x00200000 ///< Преобразовать все цвета в оттенки серого #define MGL_FULL_CURV 0x00400000 ///< Запретить пропуск точек на прямолинейных участках #define MGL_NO_SCALE_REL 0x00800000 ///< Запретить изменение размера текста в относительных inplots
- Функция С:
voidmgl_bsize (unsignedbsize) Задает размер буфера под примитивы как (1<<bsize)^2. Т.е. как 10^12 для bsize=20 или 4*10^9 для bsize=16 (по умолчанию). ВАЖНО: можно устанавливать только один раз вначале, до построения графиков. Возвращает текущее значение.
| • Transparency: | ||
| • Lighting: | ||
| • Fog: | ||
| • Default sizes: | ||
| • Cutting: | ||
| • Font settings: | ||
| • Palette and colors: | ||
| • Masks: | ||
| • Error handling: | ||
| • Stop drawing: |
Next: Lighting, Up: Graphics setup [Contents][Index]
4.2.1 Прозрачность
Эти функции и переменные настраивают тип и степень прозрачности поверхностей. Главной является функция alpha, которая включает/выключает прозрачность для всего графика. Функция alphadef устанавливает величину alpha-канала по умолчанию. Наконец, функция transptype задает тип прозрачности. См. раздел Transparency and lighting, для примеров кода и графика.
- Команда MGL: alpha
[val=on] - Метод класса
mglGraph:voidAlpha (boolenable) - Функция С:
voidmgl_set_alpha (HMGLgr,intenable) Включает/выключает прозрачность и возвращает свое предыдущее состояние. По умолчанию прозрачность выключена. Функция включает прозрачность для всего рисунка.
- Команда MGL: alphadef
val - Метод класса
mglGraph:voidSetAlphaDef (mrealval) - Функция С:
voidmgl_set_alpha_default (HMGLgr,mrealalpha) Задает значение прозрачности по умолчанию для всех графиков. Значение по умолчанию 0.5.
- Команда MGL: transptype
val - Метод класса
mglGraph:voidSetTranspType (inttype) - Функция С:
voidmgl_set_transp_type (HMGLgr,inttype) Задает тип прозрачности. Допустимые значения:
- Обычная прозрачность (‘0’) – "закрытые" объекты видны меньше чем закрывающие. Этот режим некорректно отображается в OpenGL (mglGraphGL) для нескольких перекрывающихся поверхностей.
- "Стеклянная" прозрачность (‘1’) – закрытые и закрывающие объекты единообразно ослабляют интенсивность света (по RGB каналам).
- "Ламповая" прозрачность (‘2’) – закрытые и закрывающие объекты являются источниками дополнительного освещения (рекомендую установить
SetAlphaDef(0.3)или меньше в этом случае).
См. раздел Types of transparency, для примеров кода и графика.
Next: Fog, Previous: Transparency, Up: Graphics setup [Contents][Index]
4.2.2 Освещение
Эти функции настраивают освещение графика. Главная функция light включает/выключает освещение графиков построенных после ее вызова (в OpenGL работает сразу для всего рисунка). MathGL поддерживает до 10 независимых источников света. Но в режиме OpenGL можно использовать только первые 8 из них. Положение, цвет, яркость каждого источника света можно задавать по отдельности. По умолчанию включен только первый (с порядковым номером 0) источник света белого цвета, расположенный сверху. См. раздел Lighting sample, для примеров кода и графика.
- Команда MGL: light
[val=on] - Метод класса
mglGraph:boolLight (boolenable) - Функция С:
voidmgl_set_light (HMGLgr,intenable) Включает/выключает освещение графика и возвращает предыдущее состояние. По умолчанию освещение выключено.
- Команда MGL: light
numval - Метод класса
mglGraph:voidLight (intn,boolenable) - Функция С:
voidmgl_set_light_n (HMGLgr,intn,intenable) Включает/выключает n-ый источник света.
- Команда MGL: light
num xdir ydir zdir['col'='w'br=0.5 ap=0] - Команда MGL: light
num xdir ydir zdir xpos ypos zpos['col'='w'br=0.5] - Метод класса
mglGraph:voidAddLight (intn,mglPointd,charc='w',mrealbright=0.5,mrealap=0) - Метод класса
mglGraph:voidAddLight (intn,mglPointr,mglPointd,charc='w',mrealbright=0.5,mrealap=0) - Функция С:
voidmgl_add_light (HMGLgr,intn,mrealdx,mrealdy,mrealdz) - Функция С:
voidmgl_add_light_ext (HMGLgr,intn,mrealdx,mrealdy,mrealdz,charc,mrealbright,mrealap) - Функция С:
voidmgl_add_light_loc (HMGLgr,intn,mrealrx,mrealry,mrealrz,mrealdx,mrealdy,mrealdz,charc,mrealbright,mrealap) Добавляет источник света с номером n в положение p с цветом c и яркостью bright, которая должна быть в диапазоне [0,1]. Если указано положение источника r и оно не NAN, то источник считается локальным, иначе источник полагается бесконечно удалённым (для более быстрого рисования).
- Команда MGL: diffuse
val - Метод класса
mglGraph:voidSetDifLight (mrealbright) - Функция С:
voidmgl_set_difbr (HMGLgr,mrealbright) Задает яркость диффузного освещения (только для локальных источников света).
- Команда MGL: ambient
val - Метод класса
mglGraph:voidSetAmbient (mrealbright=0.5) - Функция С:
voidmgl_set_ambbr (HMGLgr,mrealbright) Задает яркость рассеянного освещения. Значение должно быть в диапазоне [0,1].
- Команда MGL: attachlight
val - Метод класса
mglGraph:voidAttachLight (boolval) - Функция С:
voidmgl_set_attach_light (HMGLgr,intval) Задает привязку настроек освещения к inplot/subplot. Отмечу, что OpenGL и некоторые выходные форматы не поддерживают эту возможность.
Next: Default sizes, Previous: Lighting, Up: Graphics setup [Contents][Index]
4.2.3 Туман
- Команда MGL: fog
val [dz=0.25] - Метод класса
mglGraph:voidFog (mreald,mrealdz=0.25) - Функция С:
voidmgl_set_fog (HMGLgr,mreald,mrealdz) Имитирует туман на графике. Туман начинается на относительном расстоянии dz от точки обзора и его плотность растет экспоненциально вглубь по закону ~ 1-exp(-d*z). Здесь z – нормализованная на 1 глубина графика. Если d=
0то туман отсутствует. См. раздел Adding fog, для примеров кода и графика.
Next: Cutting, Previous: Fog, Up: Graphics setup [Contents][Index]
4.2.4 Базовые размеры
Эти функции задают величины большинства параметров графика, включая размеры маркеров, стрелок, толщину линий и т.д. Как и любые другие настройки, они подействуют только на графики созданные после изменения настроек.
- Команда MGL: barwidth
val - Метод класса
mglGraph:voidSetBarWidth (mrealval) - Функция С:
voidmgl_set_bar_width (HMGLgr,mrealval) Задает относительный размер прямоугольников в bars, barh, boxplot, candle. Значение по умолчанию
0.7.
- Команда MGL: marksize
val - Метод класса
mglGraph:voidSetMarkSize (mrealval) - Функция С:
voidmgl_set_mark_size (HMGLgr,mrealval) Задает размер маркеров для 1D plotting. Значение по умолчанию
1.
- Команда MGL: arrowsize
val - Метод класса
mglGraph:voidSetArrowSize (mrealval) - Функция С:
voidmgl_set_arrow_size (HMGLgr,mrealval) Задает размер стрелок для 1D plotting, линий и кривых (см. Primitives). Значение по умолчанию
1.
- Команда MGL: meshnum
val - Метод класса
mglGraph:voidSetMeshNum (intval) - Функция С:
voidmgl_set_meshnum (HMGLgr,intnum) Задает ориентировочное число линий в mesh, fall, и число стрелок (штрихов) в vect, dew, и число ячеек в cloud, и число маркеров в plot, tens, step, mark, textmark. По умолчанию (=0) рисуются все линии, стрелки, ячейки и т.д.
- Команда MGL: facenum
val - Метод класса
mglGraph:voidSetFaceNum (intval) - Функция С:
voidmgl_set_facenum (HMGLgr,intnum) Задает ориентировочное число видимых граней. Может быть использована для ускорения рисования за счет более грубого рисунка. По умолчанию (=0) рисуются все грани.
- Команда MGL: plotid 'id'
- Метод класса
mglGraph:voidSetPlotId (const char *id) - Функция С:
voidmgl_set_plotid (HMGLgr,const char *id) Задает имя графика для сохранения в файл (например, в окне FLTK).
- Метод класса
mglGraph:const char *GetPlotId () - Функция С:
const char *mgl_get_plotid (HMGLgr) - Fortran процедура:
mgl_get_plotid (longgr,char *out,intlen) Возвращает имя графика для сохранения в файл (например, в окне FLTK).
- Команда MGL: pendelta
val - Метод класса
mglGraph:voidSetPenDelta (doubleval) - Функция С:
voidmgl_pen_delta (HMGLgr,doubleval) Изменяет размытие около линий и текста (по умолчанию 1). Для val>1 текст и линии более резкие. Для val<1 текст и линии более размытые.
Next: Font settings, Previous: Default sizes, Up: Graphics setup [Contents][Index]
4.2.5 Обрезание
Эти функции задают условия когда точка будет исключена (вырезана) из рисования. Замечу, что все точки со значением(-ями) NAN по одной из координат или амплитуде автоматически исключаются из рисования. См. раздел Cutting sample, для примеров кода и графика.
- Команда MGL: cut
val - Метод класса
mglGraph:voidSetCut (boolval) - Функция С:
voidmgl_set_cut (HMGLgr,intval) Задает обрезание точек за пределами осей координат. Если
trueто такие точки исключаются из рисования (это по умолчанию) иначе они проецируются на ограничивающий прямоугольник.
- Команда MGL: cut
x1 y1 z1 x2 y2 z2 - Метод класса
mglGraph:voidSetCutBox (mglPointp1,mglPointp1) - Функция С:
voidmgl_set_cut_box (HMGLgr,mrealx1,mrealy1,mrealz1,mrealx2,mrealy2,mrealz2) Задает границы параллелепипеда внутри которого точки не рисуются. Если границы одинаковы (переменные равны), то параллелепипеда считается пустым.
- Команда MGL: cut 'cond'
- Метод класса
mglGraph:voidCutOff (const char *cond) - Функция С:
voidmgl_set_cutoff (HMGLgr,const char *cond) Задает условие обрезания по формуле cond. Это условие исключает точки из рисования если результат вычисления формулы не равен нулю. Установите аргумент
""для выключения условия обрезания.
Next: Palette and colors, Previous: Cutting, Up: Graphics setup [Contents][Index]
4.2.6 Шрифты
- Команда MGL: font 'fnt' [
val=6] Задает стиль и размер шрифта. Вначале используется ‘:rC’ – прямой шрифт с выравниванием по центру. По умолчанию размер подписей оси координат в 1.4 раза больше. См. также см. Font styles.
- Команда MGL: rotatetext
val - Метод класса
mglGraph:voidSetRotatedText (boolval) - Функция С:
voidmgl_set_rotated_text (HMGLgr,intval) Включает/выключает вращение меток и подписей осей координат вдоль оси.
- Команда MGL: scaletext
val - Метод класса
mglGraph:voidSetScaleText (boolval) - Функция С:
voidmgl_set_scale_text (HMGLgr,intval) Включает/выключает масштабирование текста в относительных inplot-ах (в том числе columnplot, gridplot, stickplot, shearplot).
- Команда MGL: loadfont ['name'='']
- Метод класса
mglGraph:voidLoadFont (const char *name,const char *path="") - Функция С:
voidmgl_load_font (HMGLgr,const char *name,const char *path) Загружает начертание шрифта из файла path/name. Пустая строка загрузит шрифт по умолчанию.
- Метод класса
mglGraph:voidSetFontDef (const char *fnt) - Функция С:
voidmgl_set_font_def (HMGLgr,const char *val) Задает стиль шрифта (см. Text printing). По умолчанию используется ‘rC’ – прямой шрифт с выравниванием по центру.
- Метод класса
mglGraph:voidSetFontSize (mrealval) - Функция С:
voidmgl_set_font_size (HMGLgr,mrealval) Задает базовый размер шрифта. По умолчанию размер подписей оси координат в 1.4 раза больше.
- Метод класса
mglGraph:voidSetFontSizePT (mrealcm,intdpi=72) Задает размер шрифта в пунктах для заданного DPI (по умолчанию 16 pt для dpi=72).
- Метод класса
mglGraph:inline voidSetFontSizeCM (mrealcm,intdpi=72) Задает размер шрифта в сантиметрах для заданного DPI (по умолчанию 0.56 см = 16 pt).
- Метод класса
mglGraph:inline voidSetFontSizeIN (mrealcm,intdpi=72) Задает размер шрифта в дюймах для заданного DPI (по умолчанию 0.22 in = 16 pt).
- Метод класса
mglGraph:voidCopyFont (mglGraph *from) - Функция С:
voidmgl_copy_font (HMGLgr,HMGLgr_from) Копирует начертание шрифта из другого объекта
mglGraph.
- Метод класса
mglGraph:voidRestoreFont () - Функция С:
voidmgl_restore_font (HMGLgr) Восстанавливает начертание шрифта по умолчанию.
- Метод класса
mglGraph:voidSetDefFont (const char *name,const char *path="") static - Функция С:
voidmgl_def_font (const char *name,const char *path) Загружает начертание шрифта по умолчанию (для всех вновь создаваемых HMGL/mglGraph объектов) из файла path/name.
Next: Masks, Previous: Font settings, Up: Graphics setup [Contents][Index]
4.2.7 Палитра и цвета
- Команда MGL: palette 'colors'
- Метод класса
mglGraph:voidSetPalette (const char *colors) - Функция С:
voidmgl_set_palette (HMGLgr,const char *colors) Задает палитру как последовательность цветов. Значение по умолчанию
"Hbgrcmyhlnqeup", что соответствует цветам: темно серый ‘H’, синий ‘b’, зелёный ‘g’, красный ‘r’, голубой ‘c’, малиновый ‘m’, жёлтый ‘y’, серый ‘h’, сине-зелёный ‘l’, небесно-голубой ‘n’, оранжевый ‘q’, желто-зелёный ‘e’, сине-фиолетовый ‘u’, фиолетовый ‘p’. Палитра в основном используется в 1D графиках (см. 1D plotting) для кривых с неопределённым стилем линии. Внутренний счетчик цвета будет сброшен при любом изменении палитры, включая скрытые (например, функциями box или axis).
- Метод класса
mglGraph:voidSetDefScheme (const char *sch) - Функция С:
voidmgl_set_def_sch (HMGLgr,const char *sch) Устанавливает sch в качестве цветовой схемы по умолчанию. Начальное значение
"BbcyrR".
- Метод класса
mglGraph:voidSetColor (charid,mrealr,mrealg,mrealb) static - Функция С:
voidmgl_set_color (charid,mrealr,mrealg,mrealb) Задает RGB значения для цвета с заданным id. Изменения действуют глобально для всех последующих использований данного id.
- Команда MGL: gray [
val=on] - Метод класса
mglGraph:voidGray (boolenable) - Функция С:
voidmgl_set_gray (HMGLgr,intenable) Включает/выключает вывод графика в оттенках серого.
Next: Error handling, Previous: Palette and colors, Up: Graphics setup [Contents][Index]
4.2.8 Маски
- Команда MGL: mask 'id' 'hex' [angle]
- Команда MGL: mask 'id' hex [angle]
- Метод класса
mglGraph:voidSetMask (charid,const char *hex) - Метод класса
mglGraph:voidSetMask (charid,uint64_thex) - Функция С:
voidmgl_set_mask (HMGLgr,const char *hex) - Функция С:
voidmgl_set_mask_val (HMGLgr,uint64_thex) Задает новую матрицу hex размером 8*8 для маски с заданным id. Изменения действуют глобально для всех последующих использований данного id. Значения по умолчанию (см. Color scheme): ‘-’ – 000000FF00000000, ‘+’ – 080808FF08080808, ‘=’ – 0000FF00FF000000, ‘;’ – 0000007700000000, ‘o’ – 0000182424180000, ‘O’ – 0000183C3C180000, ‘s’ – 00003C24243C0000, ‘S’ – 00003C3C3C3C0000, ‘~’ – 0000060990600000, ‘<’ – 0060584658600000, ‘>’ – 00061A621A060000, ‘j’ – 0000005F00000000, ‘d’ – 0008142214080000, ‘D’ – 00081C3E1C080000, ‘*’ – 8142241818244281, ‘^’ – 0000001824420000. Параметр angle позволяет сразу задать и угол поворота маски. ВАЖНО: при экспорте в EPS угол поворота будет приведен к ближайшему кратному 45 градусам.
Задает новую матрицу hex размером 8*8 для маски с заданным id. Изменения действуют глобально для всех последующих использований данного id. Значения по умолчанию (см. Color scheme): ‘-’ – линии (
0x000000FF00000000), ‘+’ – клетки (080808FF08080808), ‘=’ – двойные линии (0000FF00FF000000), ‘;’ – пунктир (0x0000000F00000000), ‘o’ – окружкости (0000182424180000), ‘O’ – круги (0000183C3C180000), ‘s’ – квадраты (00003C24243C0000), ‘S’ – закрашенные квадраты (00003C3C3C3C0000), ‘~’ – волны (0000060990600000), ‘<’ – треугольники влево (0060584658600000), ‘>’ – треугольники вправо (00061A621A060000), ‘j’ пунктир с точками (0000002700000000), ‘d’ плюсы (0x0008083E08080000), ‘D’ – стежки (0x0139010010931000), ‘*’ – точки (0x0000001818000000), ‘^’ – кирпичи (0x101010FF010101FF). Параметр angle позволяет сразу задать и угол поворота маски. ВАЖНО: при экспорте в EPS угол поворота будет приведен к ближайшему кратному 45 градусам.
- Команда MGL: mask angle
- Метод класса
mglGraph:voidSetMaskAngle (intangle) - Функция С:
voidmgl_set_mask_angle (HMGLgr,intangle) Задает угол поворота маски в градусах. Отмечу, что символы ‘\’, ‘/’, ‘I’ в цветовой схеме задают угол поворота в 45, -45 и 90 градусов соответственно. ВАЖНО: при экспорте в EPS угол поворота будет приведен к ближайшему кратному 45 градусам.
Next: Stop drawing, Previous: Masks, Up: Graphics setup [Contents][Index]
4.2.9 Обработка ошибок
Обычно вы должны сбросить признак ошибки с помощью SetWarn(0); перед построением и проверить GetWarnCode() или Message() на наличие ошибок после построения. Только последнее предупреждение сохраняется. Замечу, что все предупреждения/ошибки в MathGL не являются критичными – в худшем из вариантов соответствующий график просто не будет построен. По умолчанию, все предупреждения выводятся в stderr. Этот вывод можно выключить вызовом mgl_suppress_warn(true);.
- Метод класса
mglGraph:voidSetWarn (intcode,const char *info="") - Функция С:
voidmgl_set_warn (HMGLgr,intcode,const char *info) Задает код предупреждения. Обычно вызывается только для очистки предупреждений (
SetWarn(0);) или внутри библиотеки. Текст info будет добавлен к предупреждениям как есть при code<0.
- Метод класса
mglGraph:const char *Message () - Функция С:
const char *mgl_get_mess (HMGLgr) - Fortran процедура:
mgl_get_mess (longgr,char *out,intlen) Возвращает текст предупреждений о причине отсутствия графика. Если возвращаемая строка пустая, то сообщений нет.
- Метод класса
mglGraph:intGetWarn () - Функция С:
intmgl_get_warn (HMGLgr) Возвращает код сообщения о причине отсутствия графика. Возможные значения:
mglWarnNone=0Предупреждений нет
mglWarnDimНеправильные или несовместимые размеры данных
mglWarnLowРазмеры данных слишком малы
mglWarnNegМинимальное значение отрицательно
mglWarnFileФайл не найден или указаны неправильные размерности
mglWarnMemНе достаточно памяти
mglWarnZeroЗначение данных равно нулю
mglWarnLegНет записей в легенде
mglWarnSlcИндекс среза вне данных
mglWarnCntЧисло линий уровня меньше или равно нулю
mglWarnOpenНе могу открыть файл
mglWarnLIdLight: ID вне допустимых значений
mglWarnSizeSetsize: размер(ы) равны нулю или отрицательны
mglWarnFmtФормат не поддерживается
mglWarnTernДиапазоны осей несовместимые
mglWarnNullУказатель равен NULL
mglWarnSpcНе хватает места для графика
mglScrArgНеправильные аргументы команды скрипта MGL
mglScrCmdНеправильная команда в скрипте MGL
mglScrLongСлишком длинная строка в скрипте MGL
mglScrStrОдиночная ’ в скрипте MGL
mglScrTempИзменяется временная переменная в MGL скрипте
- Метод класса
mglGraph:voidSuppressWarn (boolstate) static - Функция С:
voidmgl_suppress_warn (intstate) Выключает вывод предупреждений в
stderrесли state не ноль.
- Метод класса
mglGraph:voidSetGlobalWarn (const char *info) static - Функция С:
voidmgl_set_global_warn (const char *info) Задает предупреждение info, не привязанное к конкретному объекту рисования.
- Метод класса
mglGraph:const char *GlobalWarn () static - Функция С:
const char *mgl_get_global_warn () Возвращает предупреждения, не привязанные к конкретному объекту рисования.
Previous: Error handling, Up: Graphics setup [Contents][Index]
4.2.10 Остановка рисования
- Метод класса
mglGraph:voidStop (boolstop=true) - Функция С only:
voidmgl_ask_stop (HMGLgr,intstop) Просит остановить рисование если stop не ноль, иначе сбрасывает флаг остановки.
- Метод класса
mglGraph:boolNeedStop () - Функция С only:
voidmgl_need_stop (HMGLgr) Возвращает
trueесли рисование должно быть остановлено. Также запускает обработку всех отложенных событий в GUI. Пользователь должен вызывать эту функцию время от времени внутри долгих вычислений для плавности отклика GUI.
- Метод класса
mglGraph:boolSetEventFunc (void (*func)(void *),void *par=NULL) - Функция С only:
voidmgl_set_event_func (HMGLgr,void (*func)(void *),void *par) Задает функцию, которая будет вызвана для обработки событий в GUI библиотеке.
Next: Subplots and rotation, Previous: Graphics setup, Up: MathGL core [Contents][Index]
4.3 Настройки осей координат
Эти функции управляет видом и масштабом осей координат. Перед построением для каждой точки выполняются 3 преобразования: сначала определяется возможность рисования точки (см. Cutting), далее применяются формулы перехода к криволинейным координатам и наконец точка отображается. Отмечу, что MathGL выдает предупреждение если масштабы осей координат лежат вне области определения формул преобразования координат.
| • Ranges (bounding box): | ||
| • Curved coordinates: | ||
| • Ticks: |
Next: Curved coordinates, Up: Axis settings [Contents][Index]
4.3.1 Масштаб осей координат
- Команда MGL: xrange
v1 v2[add=off] - Команда MGL: yrange
v1 v2[add=off] - Команда MGL: zrange
v1 v2[add=off] - Команда MGL: crange
v1 v2[add=off] - Метод класса
mglGraph:voidSetRange (chardir,mrealv1,mrealv2) - Метод класса
mglGraph:voidAddRange (chardir,mrealv1,mrealv2) - Функция С:
voidmgl_set_range_val (HMGLgr,chardir,mrealv1,mrealv2) - Функция С:
voidmgl_add_range_val (HMGLgr,chardir,mrealv1,mrealv2) Задает диапазон изменения ‘x’-,‘y’-,‘z’-,‘c’-координат. Если одно из значений равно
NAN, то оно игнорируется. Параметрadd=onуказывает добавлять новый диапазон к существующему (не заменять его). См. также ranges.
- Команда MGL: xrange dat [
add=off] - Команда MGL: yrange dat [
add=off] - Команда MGL: zrange dat [
add=off] - Команда MGL: crange dat [
add=off] - Метод класса
mglGraph:voidSetRange (chardir,const mglDataA &dat,booladd=false) - Функция С:
voidmgl_set_range_dat (HMGLgr,chardir,const HCDTa,intadd) Задает диапазон изменения ‘x’-,‘y’-,‘z’-,‘c’-координат как минимальное и максимальное значение массива dat. Параметр
add=onуказывает добавлять новый диапазон к существующему (не заменять его).
- Команда MGL: ranges
x1 x2 y1 y2 [z1=0 z2=0] - Метод класса
mglGraph:voidSetRanges (mglPointp1,mglPointp2) - Метод класса
mglGraph:voidSetRanges (mrealx1,mrealx2,mrealy1,mrealy2,mrealz1=0,mrealz2=0) - Функция С:
voidmgl_set_ranges (HMGLgr,mrealx1,mrealx2,mrealy1,mrealy2,mrealz1,mrealz2) Задает диапазон изменения координат. Если минимальное и максимальное значение координаты равны, то они игнорируются по данному направлению. Также устанавливает размер цветовой шкалы, аналогично команде
crange z1 z2. Начальные диапазоны равны [-1, 1].
- Команда MGL: ranges
xx yy [zz cc=zz] - Метод класса
mglGraph:voidSetRanges (const mglDataA &xx,const mglDataA &yy) - Метод класса
mglGraph:voidSetRanges (const mglDataA &xx,const mglDataA &yy,const mglDataA &zz) - Метод класса
mglGraph:voidSetRanges (const mglDataA &xx,const mglDataA &yy,const mglDataA &zz,const mglDataA &cc) Задает диапазон изменения ‘x’-,‘y’-,‘z’-,‘c’-координат как минимальное и максимальное значение массивов xx, yy, zz, cc соответственно.
- Метод класса
mglGraph:voidSetAutoRanges (mglPointp1,mglPointp2) - Метод класса
mglGraph:voidSetAutoRanges (doublex1,doublex2,doubley1,doubley2,doublez1=0,doublez2=0,doublec1=0,doublec2=0) - Функция С:
voidmgl_set_auto_ranges (HMGLgr,doublex1,doublex2,doubley1,doubley2,doublez1,doublez2,doublez1,doublez2) Задает диапазон изменения координат для автоматических переменных. Если минимальное и максимальное значение координаты равны, то они игнорируются по данному направлению.
- Команда MGL: origin
x0 y0 [z0=nan] - Метод класса
mglGraph:voidSetOrigin (mglPointp0) - Метод класса
mglGraph:voidSetOrigin (mrealx0,mrealy0,mrealz0=NAN) - Функция С:
voidmgl_set_origin (HMGLgr,mrealx0,mrealy0,mrealz0) Задает центр пересечения осей координат. Если одно из значений равно NAN, то MathGL попытается выбрать оптимальное положение осей координат по этому направлению.
- Команда MGL: zoomaxis
x1 x2 - Команда MGL: zoomaxis
x1 y1 x2 y2 - Команда MGL: zoomaxis
x1 y1 z1 x2 y2 z2 - Команда MGL: zoomaxis
x1 y1 z1 c1 x2 y2 z2 c2 - Метод класса
mglGraph:voidZoomAxis (mglPointp1,mglPointp2) - Функция С:
voidmgl_zoom_axis (HMGLgr,mrealx1,mrealy1,mrealz1,mrealc1,mrealx2,mrealy2,mrealz2,mrealc2) Дополнительно расширяет диапазон осей координат, задаваемый функциями
SetRangeилиSetRanges, в соответствии с формулами min += (max-min)*p1 и max += (max-min)*p1 (или min *= (max/min)^p1 и max *= (max/min)^p1 для "логарифмических" диапазонов, когда inf>max/min>100 или 0<max/min<0.01). Начальные значения [0, 1]. Внимание! эти настройки не могут быть переписаны никакими другими функциями, включаяDefaultPlotParam().
Next: Ticks, Previous: Ranges (bounding box), Up: Axis settings [Contents][Index]
4.3.2 Криволинейные координаты
- Команда MGL: axis 'fx' 'fy' 'fz' ['fa'='']
- Метод класса
mglGraph:voidSetFunc (const char *EqX,const char *EqY,const char *EqZ="",const char *EqA="") - Функция С:
voidmgl_set_func (HMGLgr,const char *EqX,const char *EqY,const char *EqZ,const char *EqA) Задает формулы перехода к криволинейным координатам. Каждая строка является математическим выражением, зависящим от старых координат ‘x’, ‘y’, ‘z’ и ‘a’ или ‘c’ для цветовой шкалы. Например, для цилиндрических координат будет
SetFunc("x*cos(y)", "x*sin(y)", "z");. Для удаления формул соответствующий параметр должен быть пустым илиNULL. Использование формул преобразования слегка замедляет программу. Параметр EqA задает аналогичную формулу для цветовой шкалы. See Textual formulas.
- Команда MGL: axis
how - Метод класса
mglGraph:voidSetCoor (inthow) - Функция С:
voidmgl_set_coor (HMGLgr,inthow) Устанавливает одну из предопределенных систем криволинейных координат в зависимости от параметра how:
mglCartesian=0декартова система (нет преобразования координат, {x,y,z});
mglPolar=1полярные координаты: {x*cos(y),x*sin(y), z};
mglSpherical=2сферические координаты: {x*sin(y)*cos(z), x*sin(y)*sin(z), x*cos(y)};
mglParabolic=3параболические координаты: {x*y, (x*x-y*y)/2, z};
mglParaboloidal=4Paraboloidal coordinates: {(x*x-y*y)*cos(z)/2, (x*x-y*y)*sin(z)/2, x*y};
mglOblate=5Oblate coordinates: {cosh(x)*cos(y)*cos(z), cosh(x)*cos(y)*sin(z), sinh(x)*sin(y)};
mglProlate=6Prolate coordinates: {sinh(x)*sin(y)*cos(z), sinh(x)*sin(y)*sin(z), cosh(x)*cos(y)};
mglElliptic=7эллиптические координаты: {cosh(x)*cos(y), sinh(x)*sin(y), z};
mglToroidal=8тороидальные координаты: {sinh(x)*cos(z)/(cosh(x)-cos(y)), sinh(x)*sin(z)/(cosh(x)-cos(y)), sin(y)/(cosh(x)-cos(y))};
mglBispherical=9бисферические координаты: {sin(y)*cos(z)/(cosh(x)-cos(y)), sin(y)*sin(z)/(cosh(x)-cos(y)), sinh(x)/(cosh(x)-cos(y))};
mglBipolar=10биполярные координаты: {sinh(x)/(cosh(x)-cos(y)), sin(y)/(cosh(x)-cos(y)), z};
mglLogLog=11Log-log координаты: {lg(x), lg(y), lg(z)};
mglLogX=12Log-x координаты: {lg(x), y, z};
mglLogY=13Log-y координаты: {x, lg(y), z}.
- Команда MGL: ternary
val - Метод класса
mglGraph:voidTernary (inttern) - Функция С:
voidmgl_set_ternary (HMGLgr,inttern) Задает рисование треугольных (Ternary, tern=
1), пирамидальных (Quaternary, tern=2) осей координат и проекций осей координат (tern=4,5,6).Ternary – специальный тип графика для 3 зависимых координат (компонент) a, b, c таких, что a+b+c=1. MathGL использует только 2 независимые координаты a=x и b=y поскольку их достаточно для построения всех графиков. При этом третья координата z является независимым параметром для построения линий уровня, поверхностей и т.д.
Соответственно Quaternary координаты – 4 зависимые координаты a, b, c и d, такие что a+b+c+d=1. MathGL использует только 2 независимые координаты a=x, b=y и d=z поскольку их достаточно для построения всех графиков.
Проекции строятся если к переменной tern добавить число
4. Так что tern=4нарисует проекции в декартовых координатах, tern=5нарисует проекции в треугольных координатах, tern=6нарисует проекции в пирамидальных координатах. Если добавить8вместо4, то текст не будет выводиться на проекциях.Используйте
Ternary(0)для возвращения к привычным координатам. См. раздел Ternary axis, для примеров кода и графика. См. раздел Axis projection, для примеров кода и графика.
Previous: Curved coordinates, Up: Axis settings [Contents][Index]
4.3.3 Метки осей
- Команда MGL: adjust ['dir'='xyzc']
- Метод класса
mglGraph:voidAdjust (const char *dir="xyzc") - Функция С:
voidmgl_adjust_ticks (HMGLgr,const char *dir) Автоматически задает шаг меток осей, число подметок и начальное положение меток для осей координат dir в виде наиболее удобном для человека. Также задает
SetTuneTicks(true). Обычно не требуется вызывать эту функцию кроме случая возвращения настроек по умолчанию.
- Команда MGL: xtick
val [sub=0 org=nan 'fact'=''] - Команда MGL: ytick
val [sub=0 org=nan 'fact'=''] - Команда MGL: ztick
val [sub=0 org=nan 'fact'=''] - Команда MGL: xtick
val sub ['fact'=''] - Команда MGL: ytick
val sub ['fact'=''] - Команда MGL: ztick
val sub ['fact'=''] - Команда MGL: ctick
val ['fact'=''] - Метод класса
mglGraph:voidSetTicks (chardir,mreald=0,intns=0,mrealorg=NAN,const char *fact="") - Метод класса
mglGraph:voidSetTicks (chardir,mreald=0,intns=0,mrealorg=NAN,const wchar_t *fact) - Функция С:
voidmgl_set_ticks (HMGLgr,chardir,mreald,intns,mrealorg) - Функция С:
voidmgl_set_ticks_fact (HMGLgr,chardir,mreald,intns,mrealorg,const char *fact) - Функция С:
voidmgl_set_ticks_factw (HMGLgr,chardir,mreald,intns,mrealorg,const wchar_t *fact) Задает шаг меток осей d, число подметок ns и начальное положение меток org для оси вдоль направления dir (используйте ’c’ для меток colorbar). Переменная d задает шаг меток (если положительна) или их число на оси (если отрицательна). Нулевое значение задает автоматическую расстановку меток. Если org=
NAN, то используется значение из переменной Org. Параметр fact задает текст, которые будет напечатан после метки оси (например, "\pi" для d=M_PI).
- Команда MGL: xtick
val1'lbl1' [val2'lbl2' ...] - Команда MGL: ytick
val1'lbl1' [val2'lbl2' ...] - Команда MGL: ztick
val1'lbl1' [val2'lbl2' ...] - Команда MGL: ctick
val1'lbl1' [val2'lbl2' ...] - Команда MGL: xtick vdat 'lbls' [
add=off] - Команда MGL: ytick vdat 'lbls' [
add=off] - Команда MGL: ztick vdat 'lbls' [
add=off] - Команда MGL: ctick vdat 'lbls' [
add=off] - Метод класса
mglGraph:voidSetTicksVal (chardir,const char *lbl,booladd=false) - Метод класса
mglGraph:voidSetTicksVal (chardir,const wchar_t *lbl,booladd=false) - Метод класса
mglGraph:voidSetTicksVal (chardir,const mglDataA &val,const char *lbl,booladd=false) - Метод класса
mglGraph:voidSetTicksVal (chardir,const mglDataA &val,const wchar_t *lbl,booladd=false) - Функция С:
voidmgl_set_ticks_str (HMGLgr,chardir,const char *lbl,booladd) - Функция С:
voidmgl_set_ticks_wcs (HMGLgr,chardir,const wchar_t *lbl,booladd) - Функция С:
voidmgl_set_ticks_val (HMGLgr,chardir,HCDTval,const char *lbl,booladd) - Функция С:
voidmgl_set_ticks_valw (HMGLgr,chardir,HCDTval,const wchar_t *lbl,booladd) Задает явное положение val и подписи lbl для меток вдоль оси dir. Если массив val не указан, то используются значения равно распределённые в диапазоне осей координат. Метки разделяются символом ‘\n’. Если в команде MGL задано только одно значение, то метка будет добавлена к существующим меткам. Используйте
SetTicks()для восстановления автоматических меток.
- Метод класса
mglGraph:voidAddTick (chardir,doubleval,const char *lbl) - Метод класса
mglGraph:voidAddTick (chardir,doubleval,const wchar_t *lbl) - Функция С:
voidmgl_add_tick (HMGLgr,chardir,doubleval,const char *lbl) - Функция С:
voidmgl_set_tickw (HMGLgr,chardir,doubleval,const wchar_t *lbl) Аналогично предыдущему, но добавляет одну метку оси к списку существующих меток.
- Команда MGL: xtick 'templ'
- Команда MGL: ytick 'templ'
- Команда MGL: ztick 'templ'
- Команда MGL: ctick 'templ'
- Метод класса
mglGraph:voidSetTickTempl (chardir,const char *templ) - Метод класса
mglGraph:voidSetTickTempl (chardir,const wchar_t *templ) - Функция С:
voidmgl_set_tick_templ (HMGLgr,const char *templ) - Функция С:
voidmgl_set_tick_templw (HMGLgr,const wchar_t *templ) Задает шаблон templ для меток вдоль x-,y-,z-оси или colorbar. Шаблон может содержать и символы TeX. Если templ=
"", то используется шаблон по умолчанию (в простейшем случае ‘%.2g’). Если шаблон начинается с символа ‘&’, то будет использовано целоеlongвместо типаdouble. Установка шаблона выключает автоматическое улучшение вида меток.
- Команда MGL: ticktime 'dir' [
dv=0'tmpl'=''] - Метод класса
mglGraph:voidSetTicksTime (chardir,mrealval,const char *templ) - Функция С:
voidmgl_set_ticks_time (HMGLgr,mrealval,const char *templ) Задает метки времени с шагом val и шаблоном templ для меток вдоль x-,y-,z-оси или colorbar. Шаблон может содержать и символы TeX. Формат шаблона templ такой же как http://www.manpagez.com/man/3/strftime/. Наиболее употребительные варианты: ‘%X’ для национального представления времени, ‘%x’ для национального представления даты, ‘%Y’ для года с цифрами столетия. Если val=0 и/или templ="", то используется автоматическая расстановка меток и/или выбор шаблона. Вы можете использовать функцию
mgl_get_time() для получения числа секунд с 1970 года до указанной даты/времени. Отмечу, что MS Visual Studio не может обрабатывать даты до 1970.
- Функция С:
doublemgl_get_time (const char*str,const char *templ) Возвращает число секунд с 1970 года до даты/времени, указанной в строке str. Формат строки задается templ, такой же как http://www.manpagez.com/man/3/strftime/. Наиболее употребительные варианты: ‘%X’ для национального представления времени, ‘%x’ для национального представления даты, ‘%Y’ для года с цифрами столетия. Отмечу, что MS Visual Studio не может обрабатывать даты до 1970.
- Команда MGL: tuneticks
val[pos=1.15] - Метод класса
mglGraph:voidSetTuneTicks (inttune,mrealpos=1.15) - Функция С:
voidmgl_tune_ticks (HMGLgr,inttune,mrealpos) Включает/выключает улучшение вида меток осей путем вынесения общего множителя (для маленьких, типа 0.001...0.002, или больших, типа 1000...2000, значений координат) или общей компоненты (для узкого диапазона, типа 0.999...1.000). Также задает положение pos общего множителя на оси: =0 около минимального значения, =1 около максимального значения.
- Команда MGL: tickshift
dx [dy=0 dz=0 dc=0] - Метод класса
mglGraph:voidSetTickShift (mglPointd) - Функция С:
voidmgl_set_tick_shift (HMGLgr,mrealdx,mrealdy,mrealdz,mrealdc) Задает значение дополнительного сдвига меток осей координат.
- Метод класса
mglGraph:voidSetTickRotate (boolval) - Функция С:
voidmgl_set_tick_rotate (HMGLgr,boolval) Включает/выключает поворот меток если их число или длина меток слишком велики.
- Метод класса
mglGraph:voidSetTickSkip (boolval) - Функция С:
voidmgl_set_tick_skip (HMGLgr,boolval) Включает/выключает пропуск меток если их число или длина меток слишком велики.
- Метод класса
mglGraph:voidSetTimeUTC (boolval) Разрешает/запрещает использование UTC времени в метках осей координат. В C/Fortran следует использовать
mgl_set_flag(gr,val, MGL_USE_GMTIME);.
- Команда MGL: origintick
val - Метод класса
mglGraph:voidSetOriginTick (boolval=true) Разрешает/запрещает рисование меток в точке пересечения осей координат. В C/Fortran следует использовать
mgl_set_flag(gr,val, MGL_NO_ORIGIN);.
- Команда MGL: ticklen
val[stt=1] - Метод класса
mglGraph:voidSetTickLen (mrealval,mrealstt=1) - Функция С:
voidmgl_set_tick_len (HMGLgr,mrealval,mrealstt) Задает относительную длину меток осей координат. Значение по умолчанию
0.1. Параметр stt>0 задает относительную длину подметок, которые вsqrt(1+stt)раз меньше.
- Команда MGL: axisstl 'stl' ['tck'='' 'sub'='']
- Метод класса
mglGraph:voidSetAxisStl (const char *stl="k",const char *tck=0,const char *sub=0) - Функция С:
voidmgl_set_axis_stl (HMGLgr,const char *stl,const char *tck,const char *sub) Задает стиль осей (stl), меток (tck) и подметок (sub) осей координат. Если stl пустая или ноль, то используется стиль по умолчанию (‘k’ или ‘w’ в зависимости от типа прозрачности). Если tck, sub пустая или ноль, то используется стиль осей (т.е. stl).
Next: Export picture, Previous: Axis settings, Up: MathGL core [Contents][Index]
4.4 Матрица преобразования
Эти функции контролируют где и как график будет расположен. Существует определенный порядок вызова этих функций для лучшего вида графика. Вначале должны вызываться функции subplot, multiplot или inplot для указания местоположения вывода. После них – функции вращения rotate, shear и aspect. И наконец любые другие функции для рисования графика. Вместо вращения графика можно вызвать функцию columnplot, gridplot, stickplot, shearplot или относительную inplot для расположения графиков в столбец одного над другим без зазора между осями. См. раздел Subplots, для примеров кода и графика.
- Команда MGL: subplot
nx ny m['stl'='<>_^'dx=0 dy=0] - Метод класса
mglGraph:voidSubPlot (intnx,intny,intm,const char *stl="<>_^",mrealdx=0,mrealdy=0) - Функция С:
voidmgl_subplot (HMGLgr,intnx,intny,intm,const char *stl) - Функция С:
voidmgl_subplot_d (HMGLgr,intnx,intny,intm,const char *stl,mrealdx,mrealdy) Помещает последующий вывод в m-ую ячейку сетки размером nx*ny от всего рисунка. Функция сбрасывает матрицу трансформации (повороты и сжатие графика) и должна вызываться первой для создания "подграфика". С эстетической точки зрения не рекомендуется вызывать эту функцию с различными (или не кратными) размерами сетки. Дополнительное место для осей/colorbar резервируется только если строка stl содержит:
- ‘L’ или ‘<’ – с левого края,
- ‘R’ или ‘>’ – с правого края,
- ‘A’ или ‘^’ – с верхнего края,
- ‘U’ или ‘_’ – с нижнего края,
- ‘#’ – место резервироваться не будет – оси координат будут занимать все доступное пространство.
Ячейка может быть дополнительно сдвинута относительно своего обычного положения на относительный размер dx, dy. Отмечу, что colorbar может находиться за пределами рисунка если выбран пустой стиль ‘’.
- Команда MGL: multiplot
nx ny m dx dy['style'='<>_^' sx sy] - Метод класса
mglGraph:voidMultiPlot (intnx,intny,intm,intdx,intdy,const char *stl="<>_^") - Функция С:
voidmgl_multiplot (HMGLgr,intnx,intny,intm,intdx,intdy,const char *stl) Помещает последующий вывод в прямоугольник из dx*dy ячеек, начиная с m-ой ячейки, сетки размером nx*ny от всего рисунка. Функция сбрасывает матрицу трансформации (повороты и сжатие графика) и должна вызываться первой для создания "подграфика". Дополнительное место для осей/colorbar резервируется если строка stl содержит:
- ‘L’ или ‘<’ – с левого края,
- ‘R’ или ‘>’ – с правого края,
- ‘A’ или ‘^’ – с верхнего края,
- ‘U’ или ‘_’ – с нижнего края,
- ‘#’ – место резервироваться не будет – оси координат будут занимать все доступное пространство.
Область вывода может быть дополнительно сдвинута относительно своего обычного положения на относительный размер sx, sy.
- Команда MGL: inplot
x1 x2 y1 y2 [rel=on] - Метод класса
mglGraph:voidInPlot (mrealx1,mrealx2,mrealy1,mrealy2,boolrel=true) - Функция С:
voidmgl_inplot (HMGLgr,mrealx1,mrealx2,mrealy1,mrealy2) - Функция С:
voidmgl_relplot (HMGLgr,mrealx1,mrealx2,mrealy1,mrealy2) Помещает последующий вывод в прямоугольную область [x1, x2]*[y1, y2] (исходный размер [0,1]*[0,1]). Эта функция позволяет поместить график в произвольную область рисунка. Если параметр rel=
true, то используется позиция относительно текущего subplot (или inplot с rel=false). Функция сбрасывает матрицу трансформации (повороты и сжатие графика) и должна вызываться первой для создания "подграфика".
- Команда MGL: columnplot
num ind [d=0] - Метод класса
mglGraph:voidColumnPlot (intnum,intind,mreald=0) - Функция С:
voidmgl_columnplot (HMGLgr,intnum,intind) - Функция С:
voidmgl_columnplot_d (HMGLgr,intnum,intind,mreald) Помещает последующий вывод в ind-ую строку столбца из num строк. Положение столбца выбирается относительно последнего вызова subplot (или inplot с rel=
false). Параметр d задает дополнительный зазор между строк.
- Команда MGL: gridplot
nx ny ind [d=0] - Метод класса
mglGraph:voidGridPlot (intnx,intny,intind,mreald=0) - Функция С:
voidmgl_gridplot (HMGLgr,intnx,intny,intind) - Функция С:
voidmgl_gridplot_d (HMGLgr,intnx,intny,intind,mreald) Помещает последующий вывод в ind-ую ячейку таблицы nx*ny. Положение ячейки выбирается относительно последнего вызова subplot (или inplot с rel=
false). Параметр d задает дополнительный зазор между ячеек.
- Команда MGL: stickplot
num ind tet phi - Метод класса
mglGraph:voidStickPlot (intnum,intind,mrealtet,mrealphi) - Функция С:
voidmgl_stickplot (HMGLgr,intnum,intind,mrealtet,mrealphi) Помещает последующий вывод в ind-ую ячейку "бруска" из num ячеек. При этом сам брусок повернут на углы tet, phi. Положение выбирается относительно последнего вызова subplot (или inplot с rel=
false).
- Команда MGL: shearplot
num ind sx sy [xd yd] - Метод класса
mglGraph:voidShearPlot (intnum,intind,mrealsx,mrealsy,mrealxd=1,mrealyd=0) - Функция С:
voidmgl_shearplot (HMGLgr,intnum,intind,mrealsx,mrealsy,mrealxd,mrealyd) Помещает последующий вывод в ind-ую ячейку "бруска" из num ячеек. При этом сама ячейка скошена на sx, sy. Направление бруска задается переменными xd и yd. Положение выбирается относительно последнего вызова subplot (или inplot с rel=
false).
- Команда MGL: title 'title' ['stl'=''
size=-2] - Метод класса
mglGraph:voidTitle (const char *txt,const char *stl="",mrealsize=-2) - Метод класса
mglGraph:voidTitle (const wchar_t *txt,const char *stl="",mrealsize=-2) - Функция С:
voidmgl_title (HMGLgr,const char *txt,const char *stl,mrealsize) - Функция С:
voidmgl_titlew (HMGLgr,const wchar_t *txt,const char *stl,mrealsize) Выводит заголовок title для текущего "подграфика" шрифтом stl с размером size. Если строка stl содержит ‘#’, то рисуется обрамляющий прямоугольник. Функция сбрасывает матрицу трансформации (повороты и сжатие графика) и должна вызываться сразу после создания "подграфика".
- Команда MGL: rotate
tetx tetz [tety=0] - Метод класса
mglGraph:voidRotate (mrealTetX,mrealTetZ,mrealTetY=0) - Функция С:
voidmgl_rotate (HMGLgr,mrealTetX,mrealTetZ,mrealTetY) Вращает систему координат относительно осей {x, z, y} последовательно на углы TetX, TetZ, TetY.
- Команда MGL: rotate
tet x y z - Метод класса
mglGraph:voidRotateN (mrealTet,mrealx,mrealy,mrealz) - Функция С:
voidmgl_rotate_vector (HMGLgr,mreal Tet,mreal x,mreal y,mreal z) Вращает систему координат относительно вектора {x, y, z} на угол Tet.
- Команда MGL: shear
sx sy - Метод класса
mglGraph:voidShear (mrealsx,mrealsy) - Функция С:
voidmgl_shear (HMGLgr,mrealsx,mrealsy) Сдвигает (скашивает) систему координат на значения sx, sy.
- Команда MGL: aspect
ax ay [az=1] - Метод класса
mglGraph:voidAspect (mrealAx,mrealAy,mrealAz=1) - Функция С:
voidmgl_aspect (HMGLgr,mrealAx,mrealAy,mrealAz) Устанавливает соотношение размеров осей в отношении Ax:Ay:Az. Для лучшего вида следует вызывать после функции rotate. Если Ax=
NAN, то функция выберет оптимальное соотношение размеров, чтобы шаг по осям x-y был одинаков. При этом, Ay задает фактор пропорциональности шага (обычно 1), или указывает на его автоматический выбор при Ay=NAN.
- Метод класса
mglGraph:voidPush () - Функция С:
voidmgl_mat_push (HMGLgr) Помещает матрицу преобразования в стек. Позднее вы можете восстановить текущее состояние с помощью функции Pop().
- Метод класса
mglGraph:voidPop () - Функция С:
voidmgl_mat_pop (HMGLgr) Заменяет (восстанавливает) матрицу преобразования на последнюю помещенную в стек матрицу.
- Метод класса
mglGraph:voidSetPlotFactor (mrealval) - Функция С:
voidmgl_set_plotfactor (HMGLgr,mrealval) Задает масштаб картинки. Не рекомендуется устанавливать значения меньше 1.5. Это аналог функции Zoom(), но применяется только к конкретному подграфику. Используйте ноль для включения автоматического масштабирования.
Также есть 3 функции, которые управляют перспективой Perspective(), масштабированием Zoom() и вращением View() всего рисунка. Т.е. они действуют как ещё одна матрица трансформации. Они были введены для вращения/приближения графика с помощью мыши. Не рекомендуется вызывать их при рисовании графика.
- Команда MGL: perspective
val - Метод класса
mglGraph:voidPerspective (mreala) - Функция С:
voidmgl_perspective (HMGLgr,mreala) Добавляет (включает) перспективу для графика. Параметр a = Depth/(Depth+dz) \in [0,1). По умолчанию (
a=0) перспектива отключена.
- Команда MGL: view
tetx tetz [tety=0] - Метод класса
mglGraph:voidView (mrealTetX,mrealTetZ,mrealTetY=0) - Функция С:
voidmgl_view (HMGLgr,mrealTetX,mrealTetZ,mrealTetY) Вращает систему координат относительно осей {x, z, y} последовательно на углы TetX, TetZ, TetY. Вращение происходит независимо от rotate. Внимание! эти настройки не могут быть переписаны функцией
DefaultPlotParam(). ИспользуйтеZoom(0,0,1,1)для возвращения к виду по умолчанию.
- Команда MGL: zoom
x1 y1 x2 y2 - Метод класса
mglGraph:voidZoom (mrealx1,mrealy1,mrealx2,mrealy2) - Функция С:
voidmgl_set_zoom (HMGLgr,mrealx1,mrealy1,mrealx2,mrealy2) Масштабирует весь рисунок. После вызова функции текущий график будет очищен и в дальнейшем рисунок будет содержать только область [x1,x2]*[y1,y2] от исходного рисунка. Координаты x1, x2, y1, y2 меняются в диапазоне от 0 до 1. Внимание! эти настройки не могут быть переписаны никакими другими функциями, включая
DefaultPlotParam(). ИспользуйтеZoom(0,0,1,1)для возвращения к виду по умолчанию.
Next: Background, Previous: Subplots and rotation, Up: MathGL core [Contents][Index]
4.5 Экспорт рисунка
Функции в этой группе сохраняют или дают доступ к полученному рисунку. Поэтом обычно они должны вызываться в конце рисования.
- Команда MGL: setsize
w h - Метод класса
mglGraph:voidSetSize (intwidth,intheight,boolclear=true) - Функция С:
voidmgl_set_size (HMGLgr,intwidth,intheight) - Функция С:
voidmgl_scale_size (HMGLgr,intwidth,intheight) Изменяет размер картинки в пикселях. Функция должна вызываться перед любыми функциями построения потому что полностью очищает содержимое рисунка при clear=
true. Функция только очищает растровый рисунок и масштабирует примитивы при clear=false.
- Команда MGL: setsizescl
factor - Метод класса
mglGraph:voidSetSizeScl (doublefactor) - Функция С:
voidmgl_set_size_scl (HMGLgr,doublefactor) Задает множитель для высоты и ширины во всех последующих вызовах setsize.
- Команда MGL: quality [
val=2] - Метод класса
mglGraph:voidSetQuality (intval=MGL_DRAW_NORM) - Функция С:
voidmgl_set_quality (HMGLgr,intval) Задает качество графика в зависимости от значения val:
MGL_DRAW_WIRE=0– нет рисования граней (наиболее быстрый),MGL_DRAW_FAST=1– нет интерполяции цвета (быстрый),MGL_DRAW_NORM=2– высокое качество (нормальный),MGL_DRAW_HIGH=3– высокое качество с рисованием 3d примитивов (стрелок и маркеров). Если установлен битMGL_DRAW_LMEM=0x4, то происходит прямое рисование в растровое изображение (меньше затраты памяти). Если установлен битMGL_DRAW_DOTS=0x8, то рисуются точки вместо примитивов (очень быстро).
- Метод класса
mglGraph:intGetQuality () - Функция С:
voidmgl_get_quality (HMGLgr) Возвращает качество графика:
MGL_DRAW_WIRE=0– нет рисования граней (наиболее быстрый),MGL_DRAW_FAST=1– нет интерполяции цвета (быстрый),MGL_DRAW_NORM=2– высокое качество (нормальный),MGL_DRAW_HIGH=3– высокое качество с рисованием 3d примитивов (стрелок и маркеров). Если установлен битMGL_DRAW_LMEM=0x4, то происходит прямое рисование в растровое изображение (меньше затраты памяти). Если установлен битMGL_DRAW_DOTS=0x8, то рисуются точки вместо примитивов (очень быстро).
- Метод класса
mglGraph:voidStartGroup (const char *name) - Функция С:
voidmgl_start_group (HMGLgr,const char *name) Начинает определение группы. Группа может содержать объекты и другие группы. Они используются для выбора части модели при приближении, изменении прозрачности и т.д.
- Метод класса
mglGraph:voidEndGroup () - Функция С:
voidmgl_end_group (HMGLgr) Завершает определение группы.
| • Export to file: | ||
| • Frames/Animation: | ||
| • Bitmap in memory: | ||
| • Parallelization: |
Next: Frames/Animation, Up: Export picture [Contents][Index]
4.5.1 Экспорт в файл
Эти функции экспортируют текущую картинку (кадр) в файл. Имя файла fname должно иметь соответствующее расширение. Параметр descr дает краткое описание картинки. Пока прозрачность поддерживается только для форматов PNG, SVG, OBJ и PRC.
- Команда MGL: write ['fname'='']
- Метод класса
mglGraph:voidWriteFrame (const char *fname="",const char *descr="") - Функция С:
voidmgl_write_frame (HMGLgr,const char *fname,const char *descr) Экспортирует текущий кадр в файл fname с типом, определяемым по расширению. Параметр descr добавляет описание (может быть пустым). Если fname пустой, то используется имя ‘frame####.jpg’, где ‘####’ – текущий номер кадра и имя ‘frame’ определяется переменной plotid.
- Команда MGL: bbox x1 y1 [x2=
-1y2=-1] - Метод класса
mglGraph:voidSetBBox (intx1=0,inty1=0,intx2=-1,inty2=-1) - Функция С:
voidmgl_set_bbox (HMGLgr,intx1,inty1,intx2,inty2) Задает область изображения, которая будет сохранена в файл 2D формата. Если x2<0 (y2<0), то исходная ширина (высота) рисунка будет использована. Если x1<0 или y1<0 или x1>=x2|Width или y1>=y2|Height, то обрезания рисунка не будет.
- Метод класса
mglGraph:voidWritePNG (const char *fname,const char *descr="",intcompr="",boolalpha=true) - Функция С:
voidmgl_write_png (HMGLgr,const char *fname,const char *descr) - Функция С:
voidmgl_write_png_solid (HMGLgr,const char *fname,const char *descr) Экспортирует текущий кадр в PNG файл. Параметры функции следующие: fname – имя файла, descr – описание файла, alpha – прозрачность фона. Если при компиляции MathGL не был определен флаг HAVE_PNG, то экспорт в файл не производится.
- Метод класса
mglGraph:voidWriteJPEG (const char *fname,const char *descr="") - Функция С:
voidmgl_write_jpg (HMGLgr,const char *fname,const char *descr) Экспортирует текущий кадр в JPEG файл. Параметры функции следующие: fname – имя файла, descr – описание файла. Если при компиляции MathGL не был определен флаг HAVE_JPEG, то экспорт в файл не производится.
- Метод класса
mglGraph:voidWriteGIF (const char *fname,const char *descr="") - Функция С:
voidmgl_write_gif (HMGLgr,const char *fname,const char *descr) Экспортирует текущий кадр в GIF файл. Параметры функции следующие: fname – имя файла, descr – описание файла. Если при компиляции MathGL не был определен флаг HAVE_GIF, то экспорт в файл не производится.
- Метод класса
mglGraph:voidWriteBMP (const char *fname,const char *descr="") - Функция С:
voidmgl_write_bmp (HMGLgr,const char *fname,const char *descr) Экспортирует текущий кадр в BMP файл. Параметры функции следующие: fname – имя файла, descr – описание файла.
- Метод класса
mglGraph:voidWriteTGA (const char *fname,const char *descr="") - Функция С:
voidmgl_write_tga (HMGLgr,const char *fname,const char *descr) Экспортирует текущий кадр в TGA файл. Параметры функции следующие: fname – имя файла, descr – описание файла.
- Метод класса
mglGraph:voidWriteEPS (const char *fname,const char *descr="") - Функция С:
voidmgl_write_eps (HMGLgr,const char *fname,const char *descr) Экспортирует текущий кадр в EPS файл, используя векторное представление графика. Вследствие чего не рекомендуется сохранять большие графики (поверхности, а особенно поверхности уровня) из-за большого размера файла. Хотя никаких внутренних ограничений на размер выходного файла нет. Для них лучше использовать растровый формат (например, PNG или JPEG). Параметры функции следующие: fname – имя файла, descr – описание файла. Если имя файла оканчивается на ‘z’ (например, ‘fname.eps.gz’), то файл автоматически архивируется в формате gzip. Отмечу, что формат EPS не поддерживает интерполяцию цвета, и картинка будет выглядеть как при использовании quality=1.
- Метод класса
mglGraph:voidWriteBPS (const char *fname,const char *descr="") - Функция С:
voidmgl_write_eps (HMGLgr,const char *fname,const char *descr) Экспортирует текущий кадр в EPS файл, используя растровое представление графика. Параметры функции следующие: fname – имя файла, descr – описание файла. Если имя файла оканчивается на ‘z’ (например, ‘fname.eps.gz’), то файл автоматически архивируется в формате gzip.
- Метод класса
mglGraph:voidWriteSVG (const char *fname,const char *descr="") - Функция С:
voidmgl_write_svg (HMGLgr,const char *fname,const char *descr) Экспортирует текущий кадр в SVG файл, используя векторное представление графика. Вследствие чего не рекомендуется сохранять большие графики (поверхности, а особенно поверхности уровня) из-за большого размера файла. Хотя никаких внутренних ограничений на размер выходного файла нет. Для них лучше использовать растровый формат (например, PNG или JPEG). Параметры функции следующие: fname – имя файла, descr – описание файла. Если имя файла оканчивается на ‘z’ (например, ‘fname.svgz’), то файл автоматически архивируется в формате gzip. Отмечу, что формат SVG не поддерживает интерполяцию цвета, и картинка будет выглядеть как при использовании quality=1.
- Метод класса
mglGraph:voidWriteTEX (const char *fname,const char *descr="") - Функция С:
voidmgl_write_tex (HMGLgr,const char *fname,const char *descr) Экспортирует текущий кадр в LaTeX файл (пакет Tikz/PGF), используя векторное представление графика. Вследствие чего не рекомендуется сохранять большие графики (поверхности, а особенно поверхности уровня) из-за большого размера файла. Хотя никаких внутренних ограничений на размер выходного файла нет. Для них лучше использовать растровый формат (например, PNG или JPEG). Параметры функции следующие: fname – имя файла, descr – описание файла. Отмечу, что сейчас отсутствует изменение размера текста (например, в subplot), что может приводить к неправильному положению надписей.
- Метод класса
mglGraph:voidWritePRC (const char *fname,const char *descr="",boolmake_pdf=true) - Функция С:
voidmgl_write_prc (HMGLgr,const char *fname,const char *descr,intmake_pdf) Экспортирует текущий кадр в PRC файл, используя векторное представление графика (см. http://en.wikipedia.org/wiki/PRC_%28file_format%29). Вследствие чего не рекомендуется сохранять большие графики (поверхности, а особенно поверхности уровня) из-за большого размера файла. Хотя никаких внутренних ограничений на размер выходного файла нет. Для них лучше использовать растровый формат (например, PNG или JPEG). Параметры функции следующие: fname – имя файла, descr – описание файла. Если параметр make_pdf=
trueи PDF был выбран при конфигурировании MathGL, то также создается соответствующий PDF файл с 3D изображением.
- Метод класса
mglGraph:voidWriteOBJ (const char *fname,const char *descr="") - Функция С:
voidmgl_write_obj (HMGLgr,const char *fname,const char *descr) Экспортирует текущий кадр в OBJ/MTL файл, используя векторное представление графика (см. OBJ формат). Вследствие чего не рекомендуется сохранять большие графики (поверхности, а особенно поверхности уровня) из-за большого размера файла. Хотя никаких внутренних ограничений на размер выходного файла нет. Для них лучше использовать растровый формат (например, PNG или JPEG). Параметры функции следующие: fname – имя файла, descr – описание файла.
- Метод класса
mglGraph:voidWriteXYZ (const char *fname,const char *descr="") - Функция С:
voidmgl_write_xyz (HMGLgr,const char *fname,const char *descr) Экспортирует текущий кадр в XYZ/XYZL/XYZF файлы, используя векторное представление графика (см. XYZ формат). Вследствие чего не рекомендуется сохранять большие графики (поверхности, а особенно поверхности уровня) из-за большого размера файла. Хотя никаких внутренних ограничений на размер выходного файла нет. Для них лучше использовать растровый формат (например, PNG или JPEG). Параметры функции следующие: fname – имя файла, descr – описание файла.
- Метод класса
mglGraph:voidWriteSTL (const char *fname,const char *descr="") - Функция С:
voidmgl_write_stl (HMGLgr,const char *fname,const char *descr) Экспортирует текущий кадр в STL файл, используя векторное представление графика (см. STL формат). Вследствие чего не рекомендуется сохранять большие графики (поверхности, а особенно поверхности уровня) из-за большого размера файла. Хотя никаких внутренних ограничений на размер выходного файла нет. Для них лучше использовать растровый формат (например, PNG или JPEG). Параметры функции следующие: fname – имя файла, descr – описание файла.
- Метод класса
mglGraph:voidWriteOFF (const char *fname,const char *descr="",boolcolored=false) - Функция С:
voidmgl_write_off (HMGLgr,const char *fname,const char *descr,boolcolored) Экспортирует текущий кадр в OFF файл, используя векторное представление графика (см. OFF формат). Вследствие чего не рекомендуется сохранять большие графики (поверхности, а особенно поверхности уровня) из-за большого размера файла. Хотя никаких внутренних ограничений на размер выходного файла нет. Для них лучше использовать растровый формат (например, PNG или JPEG). Параметры функции следующие: fname – имя файла, descr – описание файла.
- Метод класса
mglGraph:voidShowImage (const char *viewer,boolnowait=false) - Функция С:
voidmgl_show_image (const char *viewer,intnowait) Отображает текущий кадр используя внешнюю программу просмотра viewer. Функция сохраняет картинку во временный файл и вызывает viewer для его отображения. Если nowait=
true, то функция возвращает управление немедленно – не ждет пока окно просмотра будет закрыто.
- Метод класса
mglGraph:voidWriteJSON (const char *fname,const char *descr="") - Функция С:
voidmgl_write_json (HMGLgr,const char *fname,const char *descr) Экспортирует точки и примитивы в текстовый файл используя JSON format. В дальнейшем этот файл можно загрузить и просмотреть в JavaScript скрипте. Параметры функции следующие: fname – имя файла, descr – описание файла.
- Метод класса
mglGraph:voidExportMGLD (const char *fname,const char *descr="") - Функция С:
voidmgl_export_mgld (HMGLgr,const char *fname,const char *descr) Экспортирует точки и примитивы в файл MGLD format. В дальнейшем этот файл можно загрузить и просмотреть с помощью
mglview. Параметры функции следующие: fname – имя файла, descr – описание файла.
- Метод класса
mglGraph:voidImportMGLD (const char *fname,booladd=false) - Функция С:
voidmgl_import_mgld (HMGLgr,const char *fname,intadd) Импортирует точки и примитивы из файла в MGLD format. Параметры функции следующие: fname – имя файла, add – флаг добавления или замены существующих точек и примитивов.
Next: Bitmap in memory, Previous: Export to file, Up: Export picture [Contents][Index]
4.5.2 Кадры/Анимация
Эти функции позволяют создавать несколько картинок одновременно. В большинстве случаев это бесполезно, но для органов управления (см. Widget classes) это позволяет показывать анимацию. Также можно записать несколько кадров в анимированный GIF файл.
- Метод класса
mglGraph:voidNewFrame () - Функция С:
voidmgl_new_frame (HMGLgr) Создает новый кадр. Функция возвращает номер текущего кадра. В режиме OpenGL функция не должны вызываться в параллельных потоках! – используйте прямое создание списка. Функция
EndFrame()должна быть вызвана после рисования кадра для каждого вызова этой функции.
- Метод класса
mglGraph:voidEndFrame () - Функция С:
voidmgl_end_frame (HMGLgr) Завершает рисование кадра.
- Метод класса
mglGraph:intGetNumFrame () - Функция С:
intmgl_get_num_frame (HMGLgr) Возвращает число созданных кадров.
- Метод класса
mglGraph:voidGetFrame (inti) - Функция С:
voidmgl_get_frame (HMGLgr,inti) Завершает рисование кадра и сохраняет объекты рисования в кадр с номером i, который должен быть в диапазоне [0,
GetNumFrame()-1]. Функция аналогичнаEndFrame(), но не добавляет кадр в GIF изображение.
- Метод класса
mglGraph:voidGetFrame (inti) - Функция С:
voidmgl_get_frame (HMGLgr,inti) Заменяет объекты рисования на объекты из кадра с номером i. Функция работает если установлен флаг
MGL_VECT_FRAME(по умолчанию).
- Метод класса
mglGraph:voidShowFrame (inti) - Функция С:
voidmgl_show_frame (HMGLgr,inti) Добавляет объекты рисования из кадра с номером i к уже существующим. Функция работает если установлен флаг
MGL_VECT_FRAME(по умолчанию).
- Метод класса
mglGraph:voidDelFrame (inti) - Функция С:
voidmgl_del_frame (HMGLgr,inti) Удаляет объекты рисования для кадра с номером i и сдвигает нумерацию всех последующих кадров. Функция работает если установлен флаг
MGL_VECT_FRAME(по умолчанию).
- Метод класса
mglGraph:voidResetFrames () - Функция С:
voidmgl_reset_frames (HMGLgr) Сбрасывает счетчик кадров в 0.
- Метод класса
mglGraph:voidClearFrame (inti) - Функция С:
voidmgl_clear_frame (HMGLgr,inti) Очищает текущий список объектов.
- Метод класса
mglGraph:voidStartGIF (const char *fname,intms=100) - Функция С:
voidmgl_start_gif (HMGLgr,const char *fname,intms) Начинает запись кадров в анимированный GIF файл fname. Параметр ms задает задержку между кадрами в миллисекундах. Вы не должны менять размер рисунка во время создания кино. Используйте CloseGIF() для завершения записи. Эта функция не работает в режиме OpenGL.
- Метод класса
mglGraph:voidCloseGIF () - Функция С:
voidmgl_close_gif (HMGLgr) Завершает запись анимированного GIF файла.
Next: Parallelization, Previous: Frames/Animation, Up: Export picture [Contents][Index]
4.5.3 Рисование в памяти
Эти функции возвращают созданный растровый рисунок, его ширину и высоту. В дальнейшем его можно использовать в любой графической библиотеке (см. также, Widget classes) или сохранить в файл (см. также, Export to file).
- Метод класса
mglGraph:const unsigned char *GetRGB () - Метод класса
mglGraph:voidGetRGB (char *buf,intsize) - Метод класса
mglGraph:voidGetBGRN (char *buf,intsize) - Функция С:
const unsigned char *mgl_get_rgb (HMGLgr) Возвращает растровое изображение в формате RGB для текущего кадра. Формат каждого элемента (пикселя): {red, green, blue}. Число элементов Width*Height. Положение элемента {i,j} есть [3*i + 3*Width*j] (или [4*i + 4*Width*j] для
GetBGRN()). В Python вы должны предоставить буфер buf достаточного размера size, т.е. код должен выглядеть следующим образом (для Python)from mathgl import * gr = mglGraph(); bits='\t'; bits=bits.expandtabs(4*gr.GetWidth()*gr.GetHeight()); gr.GetBGRN(bits, len(bits));
- Метод класса
mglGraph:const unsigned char *GetRGBA () - Метод класса
mglGraph:voidGetRGBA (char *buf,intsize) - Функция С:
const unsigned char *mgl_get_rgba (HMGLgr) Возвращает растровое изображение в формате RGBA для текущего кадра. Формат каждого элемента (пикселя): {red, green, blue, alpha}. Число элементов Width*Height. Положение элемента {i,j} есть [4*i + 4*Width*j].
- Метод класса
mglGraph:intGetWidth () - Метод класса
mglGraph:intGetHeight () - Функция С:
intmgl_get_width (HMGLgr) - Функция С:
intmgl_get_height (HMGLgr) Возвращает ширину и высоту изображения.
- Метод класса
mglGraph:mglPointCalcXYZ (intxs,intys) - Функция С:
voidmgl_calc_xyz (HMGLgr,intxs,intys,mreal *x,mreal *y,mreal *z) Вычисляет 3D координаты {x,y,z} для экранной точки {xs,ys}. В данный момент игнорируется перспектива графика и формулы перехода в криволинейные координаты. Вычисления производятся для последнего использованного InPlot (см. Subplots and rotation).
- Метод класса
mglGraph:mglPointCalcScr (mglPointp) - Функция С:
voidmgl_calc_scr (HMGLgr,mrealx,mrealy,mrealz,int *xs,int *ys) Вычисляет экранные координаты {xs,ys} для 3D координат {x,y,z}. Вычисления производятся для последнего использованного InPlot (см. Subplots and rotation).
- Метод класса
mglGraph:voidSetObjId (intid) - Функция С:
voidmgl_set_obj_id (HMGLgr,intid) Задает числовой идентификатор для объектов или subplot/inplot.
- Метод класса
mglGraph:intGetObjId (intxs,intys) - Функция С:
intmgl_get_obj_id (HMGLgr,intxs,intys) Возвращает числовой идентификатор верхнего объекта в точке {xs, ys} рисунка.
- Метод класса
mglGraph:intGetSplId (intxs,intys) - Функция С:
intmgl_get_spl_id (HMGLgr,intxs,intys) Возвращает числовой идентификатор верхнего "подграфика" в точке {xs, ys} рисунка.
- Метод класса
mglGraph:voidHighlight (intid) - Функция С:
voidmgl_highlight (HMGLgr,intid) Выделяет объект с заданным id.
- Метод класса
mglGraph:longIsActive (intxs,intys,intd=1) - Функция С:
longmgl_is_active (HMGLgr,intxs,intys,intd) Проверяет близка ли точка {xs, ys} к активной точке (т.е. mglBase::Act) с точностью d и возвращает индекс активной точки или
-1если не найдено. Активные точки – специальные точки, которые характеризуют примитивы (например, вершины). Это функция только для опытных пользователей.
- Метод класса
mglGraph:longSetDrawReg (intnx=1,intny=1,intm=0) - Функция С:
longmgl_set_draw_reg (HMGLgr,intnx,intny,intm) Ограничивает рисование прямоугольной областью m-ой клетки матрицы размером nx*ny (аналогично subplot). Функция может бытб использована для ускорения вывода путем уменьшения выводимых примитивов. Это функция только для опытных пользователей.
Previous: Bitmap in memory, Up: Export picture [Contents][Index]
4.5.4 Распараллеливание
Многие функции MathGL используют несколько потоков для ускорения работы (если MathGL была собрана с поддержкой pthread). При этом можно настраивать число используемых потоков.
- Функция С:
intmgl_set_num_thr (intn) Задает число потоков, которое будет использовано в MathGL. При n<1 число потоков задается как максимальное число процессоров (ядер) в системе. При n=1 не используется распараллеливание.
Другая возможность – комбинирование изображений из разных объектов mglGraph. Эти методы наиболее подходят для компьютерных кластеров, когда данные настолько велики, что не могут поместиться в памяти отдельного компьютера.
- Метод класса
mglGraph:intCombine (const mglGraph *g) - Функция С:
intmgl_combine_gr (HMGLgr,HMGLg) Комбинирует (добавляет) рисунок из g с gr, принимая во внимание “высоту” пикселей. Ширина и высота обоих рисунков должна быть одинаковы.
- Метод класса
mglGraph:intMPI_Send (intid) - Функция С:
intmgl_mpi_send (HMGLgr,intid) Посылает рисунок из компьютера (ноды) id, используя MPI. Ширина и высота обоих рисунков должна быть одинаковы.
- Метод класса
mglGraph:intMPI_Recv (intid) - Функция С:
intmgl_mpi_send (HMGLgr,intid) Принимает рисунок из компьютера (ноды) id, используя MPI. Ширина и высота обоих рисунков должна быть одинаковы.
Next: Primitives, Previous: Export picture, Up: MathGL core [Contents][Index]
4.6 Фоновое изображение
These functions change background image.
- Команда MGL: clf ['col']
- Команда MGL: clf r g b
- Метод класса
mglGraph:voidClf () - Метод класса
mglGraph:voidClf (const char *col) - Метод класса
mglGraph:voidClf (charcol) - Метод класса
mglGraph:voidClf (mrealr,mrealg,mrealb) - Функция С:
voidmgl_clf (HMGLgr) - Функция С:
voidmgl_clf_str (HMGLgr,const char *col) - Функция С:
voidmgl_clf_chr (HMGLgr,charcol) - Функция С:
voidmgl_clf_rgb (HMGLgr,mrealr,mrealg,mrealb) Очищает рисунок и заполняет фон заданным цветом.
- Команда MGL: rasterize
- Метод класса
mglGraph:voidRasterize () - Функция С:
voidmgl_rasterize (HMGLgr) Завершает рисование графика и помещает результат в качестве фона. После этого, очищает список примитивов (как clf). Функция полезна для сохранения части графика (например, поверхностей или векторных полей) в растровом виде, а другой части (кривых, осей и пр.) в векторном.
- Команда MGL: background 'fname' [
alpha=1] - Метод класса
mglGraph:voidLoadBackground (const char *fname,doublealpha=1) - Функция С:
voidmgl_load_background (HMGLgr,const char *fname,doublealpha) Загружает PNG или JPEG файл fname в качестве фона для графика. Параметр alpha задает прозрачность фона вручную.
Next: Text printing, Previous: Export picture, Up: MathGL core [Contents][Index]
4.7 Рисование примитивов
Эти функции рисуют рисуют простые объекты типа линий, точек, сфер, капель, конусов, и т.д.
- Команда MGL: ball
x y['col'='r.'] - Команда MGL: ball
x y z['col'='r.'] - Метод класса
mglGraph:voidBall (mglPointp,charcol='r') - Метод класса
mglGraph:voidMark (mglPointp,const char *mark) - Функция С:
voidmgl_mark (HMGLgr,mrealx,mrealy,mrealz,const char *mark) Рисует маркер (точку по умолчанию) с координатами p={x, y, z} и цветом col.
- Команда MGL: errbox
x y ex ey['stl'=''] - Команда MGL: errbox
x y z ex ey ez['stl'=''] - Метод класса
mglGraph:voidError (mglPointp,mglPointe,char*stl="") - Функция С:
voidmgl_error_box (HMGLgr,mrealpx,mrealpy,mrealpz,mrealex,mrealey,mrealez,char *stl) Рисует 3d error box в точке p={x, y, z} размером e={ex, ey, ez} и стилем stl. Используйте NAN в компонентах e для уменьшения рисуемых элементов.
- Команда MGL: line
x1 y1 x2 y2['stl'=''] - Команда MGL: line
x1 y1 z1 x2 y2 z2['stl'=''] - Метод класса
mglGraph:voidLine (mglPointp1,mglPointp2,char *stl="B",intnum=2) - Функция С:
voidmgl_line (HMGLgr,mrealx1,mrealy1,mrealz1,mrealx2,mrealy2,mrealz2,char *stl,intnum) Рисует геодезическую линию (декартовых координатах – прямую) из точки p1 в p2 использую стиль линии stl. Параметр num определяет гладкость линии (число точек на линии). Если num=
2, то рисуется прямая даже в криволинейных координатах (см. Curved coordinates). Наоборот, для больших значений (например, =100) рисуется геодезическая линия (окружность в полярных координатах, парабола в параболических и т.д.). Линия рисуется даже если часть ее лежит вне диапазона осей координат.
- Команда MGL: curve
x1 y1 dx1 dy1 x2 y2 dx2 dy2['stl'=''] - Команда MGL: curve
x1 y1 z1 dx1 dy1 dz1 x2 y2 z2 dx2 dy2 dz2['stl'=''] - Метод класса
mglGraph:voidCurve (mglPointp1,mglPointd1,mglPointp2,mglPointd2,const char *stl="B",intnum=100) - Функция С:
voidmgl_curve (HMGLgr,mrealx1,mrealy1,mrealz1,mrealdx1,mrealdy1,mrealdz1,mrealx2,mrealy2,mrealz2,mrealdx2,mrealdy2,mrealdz2,const char *stl,intnum) Рисует кривую Безье из точки p1 в p2 используя стиль линии stl. Касательные в точках пропорциональны d1, d2. Параметр num определяет гладкость линии (число точек на линии). Если num=
2, то рисуется прямая даже в криволинейных координатах (см. Curved coordinates). Наоборот, для больших значений (например, =100) рисуется геодезическая линия (окружность в полярных координатах, парабола в параболических и т.д.). Кривая рисуется даже если часть ее лежит вне диапазона осей координат.
- Команда MGL: face
x1 y1 x2 y2 x3 y3 x4 y4['stl'=''] - Команда MGL: face
x1 y1 z1 x2 y2 z2 x3 y3 z3 x4 y4 z4['stl'=''] - Метод класса
mglGraph:voidFace (mglPointp1,mglPointp2,mglPointp3,mglPointp4,const char *stl="w") - Функция С:
voidmgl_face (HMGLgr,mrealx1,mrealy1,mrealz1,mrealx2,mrealy2,mrealz2,mrealx3,mrealy3,mrealz3,mrealx4,mrealy4,mrealz4,const char *stl) Рисует заполненный четырехугольник (грань) с углами в точках p1, p2, p3, p4 и цветом(-ами) stl. При этом цвет может быть один для всей грани, или различным если указаны все 4 цвета. Грань будет нарисована даже если часть ее лежит вне диапазона осей координат.
- Команда MGL: rect
x1 y1 x2 y2['stl'=''] - Команда MGL: rect
x1 y1 z1 x2 y2 z2['stl'=''] Рисует закрашенный прямоугольник (грань) с вершинами {x1, y1, z1} и {x2, y2, z2} цветом stl. При этом цвет может быть один для всей грани, или различным для разных вершин если указаны все 4 цвета. Грань будет нарисована даже если часть ее лежит вне диапазона осей координат.
- Команда MGL: facex
x0 y0 z0 wy wz['stl'=''d1=0 d2=0] - Команда MGL: facey
x0 y0 z0 wx wz['stl'=''d1=0 d2=0] - Команда MGL: facez
x0 y0 z0 wx wy['stl'=''d1=0 d2=0] - Метод класса
mglGraph:voidFaceX (mrealx0,mrealy0,mrealz0,mrealwy,mrealwz,const char *stl="w",mreald1=0,mreald2=0) - Метод класса
mglGraph:voidFaceY (mrealx0,mrealy0,mrealz0,mrealwx,mrealwz,const char *stl="w",mreald1=0,mreald2=0) - Метод класса
mglGraph:voidFaceZ (mrealx0,mrealy0,mrealz0,mrealwx,mrealwy,const char *stl="w",mreald1=0,mreald2=0) - Функция С:
voidmgl_facex (HMGLgr,mrealx0,mrealy0,mrealz0,mrealwy,mrealwz,const char *stl,mreald1,mreald2) - Функция С:
voidmgl_facey (HMGLgr,mrealx0,mrealy0,mrealz0,mrealwx,mrealwz,const char *stl,mreald1,mreald2) - Функция С:
voidmgl_facez (HMGLgr,mrealx0,mrealy0,mrealz0,mrealwx,mrealwy,const char *stl,mreald1,mreald2) Рисует закрашенный прямоугольник (грань) перпендикулярно оси [x,y,z] в точке {x0, y0, z0} цветом stl и шириной wx, wy, wz вдоль соответствующего направления. При этом цвет может быть один для всей грани, или различным для разных вершин если указаны все 4 цвета. Параметры d1!=0, d2!=0 задают дополнительный сдвиг последней точки (т.е. рисуют четырехугольник). Грань будет нарисована даже если часть ее лежит вне диапазона осей координат.
- Команда MGL: sphere
x0 y0 r['col'='r'] - Команда MGL: sphere
x0 y0 z0 r['col'='r'] - Метод класса
mglGraph:voidSphere (mglPointp,mrealr,const char *stl="r") - Функция С:
voidmgl_sphere (HMGLgr,mrealx0,mrealy0,mrealz0,mrealr,const char *stl) Рисует сферу радиуса r с центром в точке p={x0, y0, z0} цветом stl.
- Команда MGL: drop
x0 y0 dx dy r['col'='r'sh=1 asp=1] - Команда MGL: drop
x0 y0 z0 dx dy dz r['col'='r'sh=1 asp=1] - Метод класса
mglGraph:voidDrop (mglPointp,mglPointd,mrealr,const char *col="r",mrealshift=1,mrealap=1) - Функция С:
voidmgl_drop (HMGLgr,mrealx0,mrealy0,mrealz0,mrealdx,mrealdy,mrealdz,mrealr,const char *col,mrealshift,mrealap) Рисует каплю радиуса r в точке p вытянутую вдоль направления d цветом col. Параметр shift определяет степень вытянутости: ‘0’ – сфера, ‘1’ – классическая капля. Параметр ap определяет относительную ширину капли (аналог "эллиптичности" для сферы).
- Команда MGL: cone
x1 y1 z1 x2 y2 z2 r1[r2=-1'stl'=''edge=off] - Метод класса
mglGraph:voidCone (mglPointp1,mglPointp2,mrealr1,mrealr2=-1,const char *stl="B",booledge=false) - Функция С:
voidmgl_cone (HMGLgr,mrealx1,mrealy1,mrealz1,mrealx2,mrealy2,mrealz2,mrealr1,mrealr2,const char *stl,intdraw_edge) Рисует трубу (или усеченный конус если edge=
false) между точками p1, p2 с радиусами на концах r1, r2. Если r2<0, то полагается r2=r1. Цвет конуса задается строкой stl. Параметр stl может содержать:- ‘@’ для рисования торцов;
- ‘#’ для сетчатой фигуры;
- ‘t’ для рисования цилиндра вместо конуса/призмы;
- ‘4’, ‘6’, ‘8’ для рисования квадратной, шестиугольной или восьмиугольной призмы вместо конуса.
- Команда MGL: circle
x0 y0 r['col'='r'] - Команда MGL: circle
x0 y0 z0 r['col'='r'] - Метод класса
mglGraph:voidCircle (mglPointp,mrealr,const char *stl="r") Рисует круг радиуса r с центром в точке p={x0, y0, z0} цветом stl. Если col содержит: ‘#’ то рисуется только граница, ‘@’ то рисуется граница (вторым цветом из col или черными).
- Команда MGL: ellipse
x1 y1 x2 y2 r['col'='r'] - Команда MGL: ellipse
x1 y1 z1 x2 y2 z2 r['col'='r'] - Метод класса
mglGraph:voidEllipse (mglPointp1,mglPointp2,mrealr,const char *col="r") - Функция С:
voidmgl_ellipse (HMGLgr,mrealx1,mrealy1,mrealz1,mrealx2,mrealy2,mrealz2,mrealr,const char *col) Рисует эллипс радиуса r с фокусами в точках p1, p2 цветом stl. Если col содержит: ‘#’ то рисуется только граница, ‘@’ то рисуется граница (вторым цветом из col или черными).
- Команда MGL: rhomb
x1 y1 x2 y2 r['col'='r'] - Команда MGL: rhomb
x1 y1 z1 x2 y2 z2 r['col'='r'] - Метод класса
mglGraph:voidRhomb (mglPointp1,mglPointp2,mrealr,const char *col="r") - Функция С:
voidmgl_rhomb (HMGLgr,mrealx1,mrealy1,mrealz1,mrealx2,mrealy2,mrealz2,mrealr,const char *col) Рисует ромб ширины r с вершинами в точках p1, p2 цветом stl. Если col содержит: ‘#’ то рисуется только граница, ‘@’ то рисуется граница (вторым цветом из col или черными). Если col содержит 3 цвета, то используется градиентная заливка.
- Команда MGL: arc
x0 y0 x1 y1 a['col'='r'] - Команда MGL: arc
x0 y0 z0 x1 y1 a['col'='r'] - Команда MGL: arc
x0 y0 z0 xa ya za x1 y1 z1 a['col'='r'] - Метод класса
mglGraph:voidArc (mglPointp0,mglPointp1,mreala,const char *col="r") - Метод класса
mglGraph:voidArc (mglPointp0,mglPointpa,mglPointp1,mreala,const char *col="r") - Функция С:
voidmgl_arc (HMGLgr,mrealx0,mrealy0,mrealx1,mrealy1,mreala,const char *col) - Функция С:
voidmgl_arc_ext (HMGLgr,mrealx0,mrealy0,mrealz0,mrealxa,mrealya,mrealza,mrealx1,mrealy1,mrealz1,mreala,const char *col) Рисует дугу вокруг оси pa (по умолчанию вокруг оси z pa={0,0,1}) с центром в p0, начиная с точки p1. Параметр a задает угол дуги в градусах. Строка col задает цвет дуги и тип стрелок на краях.
- Команда MGL: polygon
x0 y0 x1 y1 num['col'='r'] - Команда MGL: polygon
x0 y0 z0 x1 y1 z1 num['col'='r'] - Метод класса
mglGraph:voidPolygon (mglPointp0,mglPointp1,intnum,const char *col="r") - Функция С:
voidmgl_polygon (HMGLgr,mrealx0,mrealy0,mrealz0,mrealx1,mrealy1,mrealz1,intnum,const char *col) Рисует правильный num-угольник с центром в p0 с первой вершиной в p1 цветом col. Если col содержит: ‘#’ то рисуется только граница, ‘@’ то рисуется граница (вторым цветом из col или черными).
- Команда MGL: logo 'fname' [smooth=off]
- Метод класса
mglGraph:voidLogo (const char *fname,boolsmooth=false,const char *opt="") - Метод класса
mglGraph:voidLogo (longw,longh,const unsigned char *rgba,boolsmooth=false,const char *opt="") - Функция С:
voidmgl_logo (HMGLgr,longw,longh,const unsigned char *rgba,boolsmooth,const char *opt) - Функция С:
voidmgl_logo_file (HMGLgr,const char *fname,boolsmooth,const char *opt) Draw bitmap (logo) along whole axis range, which can be changed by Command options. Bitmap can be loaded from file or specified as RGBA values for pixels. Parameter smooth set to draw bitmap without or with color interpolation.
- Команда MGL: symbol
x y'id' ['fnt'=''size=-1] - Команда MGL: symbol
x y z'id' ['fnt'=''size=-1] - Метод класса
mglGraph:voidSymbol (mglPointp,charid,const char *fnt="",mrealsize=-1) - Функция С:
voidmgl_symbol (HMGLgr,mrealx,mrealy,mrealz,charid,const char *fnt,mrealsize) Рисует определенный пользователем символ с именем id в точке p стилем fnt. Размер задается параметром size (по умолчанию
-1). Строка fnt может содержать цвет (до разделителя ‘:’); стили ‘a’ или ‘A’ для вывода в абсолютной позиции ({x, y} полагаются в диапазоне [0,1]) относительно рисунка (для ‘A’) или subplot/inplot (для ‘a’); и стиль ‘w’ для рисования только контура символа.
- Команда MGL: symbol
x y dx dy'id' ['fnt'=':L'size=-1] - Команда MGL: symbol
x y z dx dy dz'id' ['fnt'=':L'size=-1] - Метод класса
mglGraph:voidSymbol (mglPointp,mglPointd,charid,const char *fnt="",mrealsize=-1) - Функция С:
voidmgl_symbol_dir (HMGLgr,mrealx,mrealy,mrealz,mrealdx,mrealdy,mrealdz,const char *text,const char *fnt,mrealsize) Аналогично предыдущему, но символ рисуется в повернутым в направлении d.
- Команда MGL: addsymbol 'id' xdat ydat
- Метод класса
mglGraph:voidDefineSymbol (charid,const mglDataA &xdat,const mglDataA &ydat) - Функция С:
voidmgl_define_symbol (HMGLgr,HCDTxdat,HCDTydat) Добавляет определенный пользователем символ с именем id и границей {xdat, ydat}. Значения
NANзадают разрыв (скачок) граничной кривой.
Next: Axis and Colorbar, Previous: Primitives, Up: MathGL core [Contents][Index]
4.8 Вывод текста
Функции для вывода текста позволяют вывести строку текста в произвольном месте рисунка, в произвольном направлении и вдоль произвольной кривой. MathGL позволяет использовать произвольное начертание шрифта и многие ТеХ-ие команды (детальнее см. Font styles). Все функции вывода текста имеют варианты для 8-bit строк (char *) и для Unicode строк (wchar_t *). В первом случае используется конверсия из текущей локали, т.е. иногда вам требуется явно указать локаль с помощью функции setlocale(). Аргумент size определяет размер текста: размер шрифта если положителен или относительный размер (=-size*SetFontSize()) если отрицателен. Начертание шрифта (STIX, arial, courier, times и др.) можно изменить с помощью функции LoadFont(). See Font settings.
Параметры шрифта задаются строкой, которая может содержать символы цвета ‘wkrgbcymhRGBCYMHW’ (см. Color styles). Также после символа ‘:’ можно указать символы стиля (‘rbiwou’) и/или выравнивания (‘LRCTV’). Стили шрифта: ‘r’ – прямой, ‘i’ – курсив, ‘b’ – жирный, ‘w’ – контурный, ‘o’ – надчеркнутый, ‘u’ – подчеркнутый. По умолчанию используется прямой шрифт. Типы выравнивания: ‘L’ – по левому краю (по умолчанию), ‘C’ – по центру, ‘R’ – по правому краю, ‘T’ – под текстом, ‘V’ – по центру вертикально. Например, строка ‘b:iC’ соответствует курсиву синего цвета с выравниванием по центру. Начиная с MathGL версии 2.3, вы можете задать цветовой градиент для выводимой строки (см. Color scheme).
Если строка содержит символы ‘aA’, то текст выводится в абсолютных координатах (полагаются в диапазоне [0,1]). При этом используются координаты относительно рисунка (если указано ‘A’) или относительно последнего subplot/inplot (если указано ‘a’). Если строка содержит символ ‘@’, то вокруг текста рисуется прямоугольник.
См. раздел Text features, для примеров кода и графика.
- Команда MGL: text
x y'text' ['fnt'=''size=-1] - Команда MGL: text
x y z'text' ['fnt'=''size=-1] - Метод класса
mglGraph:voidPuts (mglPointp,const char *text,const char *fnt=":C",mrealsize=-1) - Метод класса
mglGraph:voidPutsw (mglPointp,const wchar_t *text,const char *fnt=":C",mrealsize=-1) - Метод класса
mglGraph:voidPuts (mrealx,mrealy,const char *text,const char *fnt=":AC",mrealsize=-1) - Метод класса
mglGraph:voidPutsw (mrealx,mrealy,const wchar_t *text,const char *fnt=":AC",mrealsize=-1) - Функция С:
voidmgl_puts (HMGLgr,mrealx,mrealy,mrealz,const char *text,const char *fnt,mrealsize) - Функция С:
voidmgl_putsw (HMGLgr,mrealx,mrealy,mrealz,const wchar_t *text,const char *fnt,mrealsize) Выводит строку text от точки p шрифтом определяемым строкой fnt. Размер шрифта задается параметром size (по умолчанию
-1).
- Команда MGL: text
x y dx dy'text' ['fnt'=':L'size=-1] - Команда MGL: text
x y z dx dy dz'text' ['fnt'=':L'size=-1] - Метод класса
mglGraph:voidPuts (mglPointp,mglPointd,const char *text,const char *fnt=':L',mrealsize=-1) - Метод класса
mglGraph:voidPutsw (mglPointp,mglPointd,const wchar_t *text,const char *fnt=':L',mrealsize=-1) - Функция С:
voidmgl_puts_dir (HMGLgr,mrealx,mrealy,mrealz,mrealdx,mrealdy,mrealdz,const char *text,const char *fnt,mrealsize) - Функция С:
voidmgl_putsw_dir (HMGLgr,mrealx,mrealy,mrealz,mrealdx,mrealdy,mrealdz,const wchar_t *text,const char *fnt,mrealsize) Выводит строку text от точки p вдоль направления d. Параметр fnt задает стиль текста и указывает выводить текст под линией (‘T’) или над ней (‘t’).
- Команда MGL: fgets
x y'fname' [n=0'fnt'=''size=-1.4] - Команда MGL: fgets
x y z'fname' [n=0'fnt'=''size=-1.4] Выводит n-ую строку файла fname от точки {x,y,z} шрифтом fnt и размером size. По умолчанию используются параметры заданные командой font.
- Команда MGL: text ydat 'text' ['fnt'='']
- Команда MGL: text xdat ydat 'text' ['fnt'=''
size=-1 zval=nan] - Команда MGL: text xdat ydat zdat 'text' ['fnt'=''
size=-1] - Метод класса
mglGraph:voidText (const mglDataA &y,const char *text,const char *fnt="",const char *opt="") - Метод класса
mglGraph:voidText (const mglDataA &y,const wchar_t *text,const char *fnt="",const char *opt="") - Метод класса
mglGraph:voidText (const mglDataA &x,const mglDataA &y,const char *text,const char *fnt="",const char *opt="") - Метод класса
mglGraph:voidText (const mglDataA &x,const mglDataA &y,const wchar_t *text,const char *fnt="",const char *opt="") - Метод класса
mglGraph:voidText (const mglDataA &x,const mglDataA &y,const mglDataA &z,const char *text,const char *fnt="",const char *opt="") - Метод класса
mglGraph:voidText (const mglDataA &x,const mglDataA &y,const mglDataA &z,const wchar_t *text,const char *fnt="",const char *opt="") - Функция С:
voidmgl_text_y (HMGLgr,HCDTy,const char *text,const char *fnt,const char *opt) - Функция С:
voidmgl_textw_y (HMGLgr,HCDTy,const wchar_t *text,const char *fnt,const char *opt) - Функция С:
voidmgl_text_xy (HCDTx,HCDTy,const char *text,const char *fnt,const char *opt) - Функция С:
voidmgl_textw_xy (HCDTx,HCDTy,const wchar_t *text,const char *fnt,const char *opt) - Функция С:
voidmgl_text_xyz (HCDTx,HCDTy,HCDTz,const char *text,const char *fnt,const char *opt) - Функция С:
voidmgl_textw_xyz (HCDTx,HCDTy,HCDTz,const wchar_t *text,const char *fnt,const char *opt) Выводит строку text вдоль кривой {x[i], y[i], z[i]} шрифтом fnt. Строка fnt может содержать символы: ‘t’ для вывода текста под кривой (по умолчанию), или ‘T’ для вывода текста под кривой. Размеры по 1-ой размерности должны быть одинаковы для всех массивов
x.nx=y.nx=z.nx. Если массив x не указан, то используется "автоматический" массив со значениями в диапазоне осей координат (см. Ranges (bounding box)). Если массив z не указан, то используется минимальное значение оси z. Строка opt содержит опции команды (см. Command options).
Next: Legend, Previous: Text printing, Up: MathGL core [Contents][Index]
4.9 Оси и Colorbar
Эти функции рисуют объекты для "измерения" типа осей координат, цветовой таблицы (colorbar), сетку по осям, обрамляющий параллелепипед и подписи по осям координат. См. также см. Axis settings.
- Команда MGL: axis ['dir'='xyz' 'stl'='']
- Метод класса
mglGraph:voidAxis (const char *dir="xyz",const char *stl="",const char *opt="") - Функция С:
voidmgl_axis (HMGLgr,const char *dir,const char *stl,const char *opt) Рисует оси координат и метки на них (см. Axis settings) в направлениях ‘xyz’, указанных строкой dir. Строка dir может содержать:
- ‘xyz’ для рисования соответствующих осей;
- ‘XYZ’ для рисования соответствующих осей с метками с другой стороны;
- ‘~’ или ‘_’ для осей без подписей;
- ‘U’ для невращаемых подписей;
- ‘^’ для инвертирования положения по умолчанию;
- ‘!’ для отключения улучшения вида меток (см. tuneticks);
- ‘AKDTVISO’ для вывода стрелки на конце оси;
- ‘a’ для принудительной автоматической расстановки меток;
- ‘:’ для рисования линий через точку (0,0,0);
- ‘f’ для вывода чисел в фиксированном формате;
- ‘E’ для вывода ‘E’ вместо ‘e’;
- ‘F’ для вывода в формате LaTeX;
- ‘+’ для вывода ‘+’ для положительных чисел;
- ‘-’ для вывода обычного ‘-’;
- ‘0123456789’ для задания точности при выводе чисел.
Стиль меток и оси(ей) задается строкой stl. Опция
valueзадает угол вращения меток оси. См. раздел Axis and ticks, для примеров кода и графика.
- Команда MGL: colorbar ['sch'='']
- Метод класса
mglGraph:voidColorbar (const char *sch="") - Функция С:
voidmgl_colorbar (HMGLgr,const char *sch) Рисует полосу соответствия цвета и числовых значений (colorbar) для цветовой схемы sch (используется текущая для
sch="") с краю от графика. Строка sch также может содержать:- ‘<>^_’ для расположения слева, справа, сверху или снизу соответственно;
- ‘I’ для расположения около осей (по умолчанию, на краях subplot);
- ‘A’ для использования абсолютных координат (относительно рисунка);
- ‘~’ для colorbar без подписей;
- ‘!’ для отключения улучшения вида меток (см. tuneticks);
- ‘a’ для принудительной автоматической расстановки меток;
- ‘f’ для вывода чисел в фиксированном формате;
- ‘E’ для вывода ‘E’ вместо ‘e’;
- ‘F’ для вывода в формате LaTeX;
- ‘+’ для вывода ‘+’ для положительных чисел;
- ‘-’ для вывода обычного ‘-’;
- ‘0123456789’ для задания точности при выводе чисел.
См. раздел Colorbars, для примеров кода и графика.
- Команда MGL: colorbar vdat ['sch'='']
- Метод класса
mglGraph:voidColorbar (const mglDataA &v,const char *sch="") - Функция С:
voidmgl_colorbar_val (HMGLgr,HCDTv,const char *sch) Аналогично предыдущему, но для цветовой схемы без сглаживания с заданными значениями v. См. раздел contd sample, для примеров кода и графика.
- Команда MGL: colorbar 'sch'
x y [w=1 h=1] - Метод класса
mglGraph:voidColorbar (const char *sch,mrealx,mrealy,mrealw=1,mrealh=1) - Функция С:
voidmgl_colorbar_ext (HMGLgr,const char *sch,mrealx,mrealy,mrealw,mrealh) Аналогично первому, но в произвольном месте графика {x, y} (полагаются в диапазоне [0,1]). Параметры w, h задают относительную ширину и высоту colorbar.
- Команда MGL: colorbar vdat 'sch'
x y [w=1 h=1] - Метод класса
mglGraph:voidColorbar (const mglDataA &v,const char *sch,mrealx,mrealy,mrealw=1,mrealh=1) - Функция С:
voidmgl_colorbar_val_ext (HMGLgr,HCDTv,const char *sch,mrealx,mrealy,mrealw,mrealh) Аналогично предыдущему, но для цветовой схемы sch без сглаживания с заданными значениями v. См. раздел contd sample, для примеров кода и графика.
- Команда MGL: grid ['dir'='xyz' 'pen'='B']
- Метод класса
mglGraph:voidGrid (const char *dir="xyz",const char *pen="B",const char *opt="") - Функция С:
voidmgl_axis_grid (HMGLgr,const char *dir,const char *pen,const char *opt) Рисует линии сетки в направлениях перпендикулярным dir. Если dir содержит ‘!’, то линии рисуются также и для координат под-меток. Шаг сетки такой же как у меток осей координат. Стиль линий задается параметром pen (по умолчанию – сплошная темно синяя линия ‘B-’).
- Команда MGL: box ['stl'='k'
ticks=on] - Метод класса
mglGraph:voidBox (const char *col="",boolticks=true) - Функция С:
voidmgl_box (HMGLgr) - Функция С:
voidmgl_box_str (HMGLgr,const char *col,intticks) Рисует ограничивающий параллелепипед цветом col. Если col содержит ‘@’, то рисуются закрашенные задние грани. При этом первый цвет используется для граней (по умолчанию светло жёлтый), а последний для рёбер и меток.
- Команда MGL: xlabel 'text' [
pos=1] - Команда MGL: ylabel 'text' [
pos=1] - Команда MGL: zlabel 'text' [
pos=1] - Команда MGL: tlabel 'text' [
pos=1] - Команда MGL: clabel 'text' [
pos=1] - Метод класса
mglGraph:voidLabel (chardir,const char *text,mrealpos=1,const char *opt="") - Метод класса
mglGraph:voidLabel (chardir,const wchar_t *text,mrealpos=1,const char *opt="") - Функция С:
voidmgl_label (HMGLgr,chardir,const char *text,mrealpos,const char *opt) - Функция С:
voidmgl_labelw (HMGLgr,chardir,const wchar_t *text,mrealpos,const char *opt) Выводит подпись text для оси dir=‘x’,‘y’,‘z’,‘t’,‘c’, где ‘t’ – “тернарная” ось t=1-x-y; ‘c’ – для цвета (следует вызывать после colorbar). Параметр pos задает положение подписи: при pos=0 – по центру оси, при pos>0 – около максимальных значений, при pos<0 – около минимальных значений. Опция
valueзадает дополнительный сдвиг текста. See Text printing.
Next: 1D plotting, Previous: Axis and Colorbar, Up: MathGL core [Contents][Index]
4.10 Легенда
Эти функции обеспечивают рисование легенды графика (полезно для 1D plotting). Запись в легенде состоит из двух строк: одна для стиля линии и маркеров, другая с текстом описания (с включенным разбором TeX-их команд). Можно использовать непосредственно массивы строк, или накопление во внутренние массивы с помощью функции AddLegend() с последующим отображением. Положение легенды можно задать автоматически или вручную. Параметры fnt и size задают стиль и размер шрифта (см. Font settings). Опция value задает зазор между примером линии и текстом (по умолчанию 0.1). Опция size задает размер текста. Если стиль линии пустой, то соответствующий текст печатается без отступа. Строка fnt может содержать:
- стиль текста для записей;
- ‘A’ для расположения относительно всего рисунка, а не текущего subplot;
- ‘^’ для размещения снаружи от указанных координат;
- ‘#’ для вывода прямоугольника вокруг легенды;
- ‘-’ для горизонтального расположения записей;
- цвета для заливки (1-ый), для границы (2-ой) и для текста записей (3-ий). Если указано меньше трех цветов, то цвет границы черный (для 2 и менее цветов), и цвет заливки белый (для 1 и менее цвета).
См. раздел Legend sample, для примеров кода и графика.
- Команда MGL: legend [
pos=3'fnt'='#'] - Метод класса
mglGraph:voidLegend (intpos=0x3,const char *fnt="#",const char *opt="") - Функция С:
voidmgl_legend (HMGLgr,intpos,const char *fnt,const char *opt) Рисует легенду из накопленных записей шрифтом fnt. Параметр pos задает положение легенды: ‘0’ – в нижнем левом углу, ‘1’ – нижнем правом углу, ‘2’ – верхнем левом углу, ‘3’ – верхнем правом углу (по умолчанию). Опция
valueзадает зазор между примером линии и текстом (по умолчанию 0.1).
- Команда MGL: legend
x y['fnt'='#'] - Метод класса
mglGraph:voidLegend (mrealx,mrealy,const char *fnt="#",const char *opt="") - Функция С:
voidmgl_legend_pos (HMGLgr,mrealx,mrealy,const char *fnt,const char *opt) Рисует легенду из накопленных записей шрифтом fnt. Положение легенды задается параметрами x, y, которые полагаются нормированными в диапазоне [0,1]. Опция
valueзадает зазор между примером линии и текстом (по умолчанию 0.1).
- Команда MGL: addlegend 'text' 'stl'
- Метод класса
mglGraph:voidAddLegend (const char *text,const char *style) - Метод класса
mglGraph:voidAddLegend (const wchar_t *text,const char *style) - Функция С:
voidmgl_add_legend (HMGLgr,const char *text,const char *style) - Функция С:
voidmgl_add_legendw (HMGLgr,const wchar_t *text,const char *style) Добавляет описание text кривой со стилем style (см. Line styles) во внутренний массив записей легенды.
- Команда MGL: clearlegend
- Метод класса
mglGraph:voidClearLegend () - Функция С:
voidmgl_clear_legend (HMGLgr) Очищает внутренний массив записей легенды.
- Команда MGL: legendmarks
val - Метод класса
mglGraph:voidSetLegendMarks (intnum) - Функция С:
voidmgl_set_legend_marks (HMGLgr,intnum) Задает число маркеров в легенде. По умолчанию используется 1 маркер.
Next: 2D plotting, Previous: Legend, Up: MathGL core [Contents][Index]
4.11 1D графики
Эти функции строят графики для одномерных (1D) массивов. Одномерными считаются массивы, зависящие только от одного параметра (индекса) подобно кривой в параметрической форме {x(i),y(i),z(i)}, i=1...n. По умолчанию (если отсутствуют) значения x[i] равно распределены в диапазоне оси х, и z[i] равно минимальному значению оси z. Графики рисуются для каждой строки массива данных если он двумерный. Размер по 1-ой координате должен быть одинаков для всех массивов x.nx=y.nx=z.nx.
Строка pen задает цвет и стиль линии и маркеров (см. Line styles). По умолчанию (pen="") рисуется сплошная линия с текущим цветом из палитры (см. Palette and colors). Символ ‘!’ в строке задает использование нового цвета из палитры для каждой точки данных (не для всей кривой, как по умолчанию). Строка opt задает опции графика (см. Command options).
- Команда MGL: plot ydat ['stl'='']
- Команда MGL: plot xdat ydat ['stl'='']
- Команда MGL: plot xdat ydat zdat ['stl'='']
- Метод класса
mglGraph:voidPlot (const mglDataA &y,const char *pen="",const char *opt="") - Метод класса
mglGraph:voidPlot (const mglDataA &x,const mglDataA &y,const char *pen="",const char *opt="") - Метод класса
mglGraph:voidPlot (const mglDataA &x,const mglDataA &y,const mglDataA &z,const char *pen="",const char *opt="") - Функция С:
voidmgl_plot (HMGLgr,HCDTy,const char *pen,const char *opt) - Функция С:
voidmgl_plot_xy (HMGLgr,HCDTx,HCDTy,const char *pen,const char *opt) - Функция С:
voidmgl_plot_xyz (HMGLgr,HCDTx,HCDTy,HCDTz,const char *pen,const char *opt) Функции рисуют ломанную линию по точкам {x[i], y[i], z[i]}. Если pen содержит ‘a’, то рисуются и сегменты между точками вне диапазона осей координат. Если pen содержит ‘~’, то число сегментов уменьшается для квази-линейных участков. См. также area, step, stem, tube, mark, error, belt, tens, tape, meshnum. См. раздел plot sample, для примеров кода и графика.
- Команда MGL: radar adat ['stl'='']
- Метод класса
mglGraph:voidRadar (const mglDataA &a,const char *pen="",const char *opt="") - Функция С:
voidmgl_radar (HMGLgr,HCDTa,const char *pen,const char *opt) Функции рисуют radar chart, представляющий собой ломанную с вершинами на радиальных линиях (типа ломанной в полярных координатах). Параметр
valueв опциях opt задает дополнительный сдвиг данных (т.е. использование a+valueвместо a). Если pen содержит ‘#’, то рисуется "сетка" (радиальные линии). Если pen содержит ‘a’, то рисуются и сегменты между точками вне диапазона осей координат. См. также plot, meshnum. См. раздел radar sample, для примеров кода и графика.
- Команда MGL: step ydat ['stl'='']
- Команда MGL: step xdat ydat ['stl'='']
- Команда MGL: step xdat ydat zdat ['stl'='']
- Метод класса
mglGraph:voidStep (const mglDataA &y,const char *pen="",const char *opt="") - Метод класса
mglGraph:voidStep (const mglDataA &x,const mglDataA &y,const char *pen="",const char *opt="") - Метод класса
mglGraph:voidStep (const mglDataA &x,const mglDataA &y,const mglDataA &z,const char *pen="",const char *opt="") - Функция С:
voidmgl_step (HMGLgr,HCDTy,const char *pen,const char *opt) - Функция С:
voidmgl_step_xy (HMGLgr,HCDTx,HCDTy,const char *pen,const char *opt) - Функция С:
voidmgl_step_xyz (HMGLgr,HCDTx,HCDTy,HCDTz,const char *pen,const char *opt) Функции рисуют ступеньки для точек массива. Если x.nx>y.nx, то массив x задает границы ступенек, а не их конец. См. также plot, stem, tile, boxs, meshnum. См. раздел step sample, для примеров кода и графика.
- Команда MGL: tens ydat cdat ['stl'='']
- Команда MGL: tens xdat ydat cdat ['stl'='']
- Команда MGL: tens xdat ydat zdat cdat ['stl'='']
- Метод класса
mglGraph:voidTens (const mglDataA &y,const mglDataA &c,const char *pen="",const char *opt="") - Метод класса
mglGraph:voidTens (const mglDataA &x,const mglDataA &y,const mglDataA &c,const char *pen="",const char *opt="") - Метод класса
mglGraph:voidTens (const mglDataA &x,const mglDataA &y,const mglDataA &z,const mglDataA &c,const char *pen="",const char *opt="") - Функция С:
voidmgl_tens (HMGLgr,HCDTy,HCDTc,const char *pen,const char *opt) - Функция С:
voidmgl_tens_xy (HMGLgr,HCDTx,HCDTy,HCDTc,const char *pen,const char *opt) - Функция С:
voidmgl_tens_xyz (HMGLgr,HCDTx,HCDTy,HCDTz,HCDTc,const char *pen,const char *opt) Функции рисуют ломанную линию по точкам с цветом, определяемым массивом c (типа графика натяжений). Строка pen задает цветовую схему (см. Color scheme) и стиль линий и/или маркеров (см. Line styles). Если pen содержит ‘a’, то рисуются и сегменты между точками вне диапазона осей координат. Если pen содержит ‘~’, то число сегментов уменьшается для квази-линейных участков. См. также plot, mesh, fall, meshnum. См. раздел tens sample, для примеров кода и графика.
- Команда MGL: tape ydat ['stl'='']
- Команда MGL: tape xdat ydat ['stl'='']
- Команда MGL: tape xdat ydat zdat ['stl'='']
- Метод класса
mglGraph:voidTape (const mglDataA &y,const char *pen="",const char *opt="") - Метод класса
mglGraph:voidTape (const mglDataA &x,const mglDataA &y,const char *pen="",const char *opt="") - Метод класса
mglGraph:voidTape (const mglDataA &x,const mglDataA &y,const mglDataA &z,const char *pen="",const char *opt="") - Функция С:
voidmgl_tape (HMGLgr,HCDTy,const char *pen,const char *opt) - Функция С:
voidmgl_tape_xy (HMGLgr,HCDTx,HCDTy,const char *pen,const char *opt) - Функция С:
voidmgl_tape_xyz (HMGLgr,HCDTx,HCDTy,HCDTz,const char *pen,const char *opt) Функции рисуют ленты, которые вращаются вокруг кривой {x[i], y[i], z[i]} как её нормали. Начальная лента(ы) выбираются в плоскости x-y (для ‘x’ в pen) и/или y-z (для ‘x’ в pen). Ширина лент пропорциональна barwidth, а также может быть изменена опцией
value. См. также plot, flow, barwidth. См. раздел tape sample, для примеров кода и графика.
- Команда MGL: area ydat ['stl'='']
- Команда MGL: area xdat ydat ['stl'='']
- Команда MGL: area xdat ydat zdat ['stl'='']
- Метод класса
mglGraph:voidArea (const mglDataA &y,const char *pen="",const char *opt="") - Метод класса
mglGraph:voidArea (const mglDataA &x,const mglDataA &y,const char *pen="",const char *opt="") - Метод класса
mglGraph:voidArea (const mglDataA &x,const mglDataA &y,const mglDataA &z,const char *pen="",const char *opt="") - Функция С:
voidmgl_area (HMGLgr,HCDTy,const char *pen,const char *opt) - Функция С:
voidmgl_area_xy (HMGLgr,HCDTx,HCDTy,const char *pen,const char *opt) - Функция С:
voidmgl_area_xyz (HMGLgr,HCDTx,HCDTy,HCDTz,const char *pen,const char *opt) Функции рисуют ломанную линию между точками и закрашивает её вниз до плоскости осей координат. Градиентная заливка используется если число цветов равно удвоенному число кривых. Если pen содержит ‘#’, то рисуется только каркас. Если pen содержит ‘a’, то рисуются и сегменты между точками вне диапазона осей координат. См. также plot, bars, stem, region. См. раздел area sample, для примеров кода и графика.
- Команда MGL: region ydat1 ydat2 ['stl'='']
- Команда MGL: region xdat ydat1 ydat2 ['stl'='']
- Команда MGL: region xdat1 ydat1 xdat2 ydat2 ['stl'='']
- Команда MGL: region xdat1 ydat1 zdat1 xdat2 ydat2 zdat2 ['stl'='']
- Метод класса
mglGraph:voidRegion (const mglDataA &y1,const mglDataA &y2,const char *pen="",const char *opt="") - Метод класса
mglGraph:voidRegion (const mglDataA &x,const mglDataA &y1,const mglDataA &y2,const char *pen="",const char *opt="") - Метод класса
mglGraph:voidRegion (const mglDataA &x1,const mglDataA &y1,const mglDataA &x2,const mglDataA &y2,const char *pen="",const char *opt="") - Метод класса
mglGraph:voidRegion (const mglDataA &x1,const mglDataA &y1,const mglDataA &z1,const mglDataA &x2,const mglDataA &y2,const mglDataA &z2,const char *pen="",const char *opt="") - Функция С:
voidmgl_region (HMGLgr,HCDTy1,HCDTy2,const char *pen,const char *opt) - Функция С:
voidmgl_region_xy (HMGLgr,HCDTx,HCDTy1,HCDTy2,const char *pen,const char *opt) - Функция С:
voidmgl_region_3d (HMGLgr,HCDTx1,HCDTy1,HCDTz1,HCDTx2,HCDTy2,HCDTz2,const char *pen,const char *opt) Функции закрашивают область между 2 кривыми. Градиентная заливка используется если число цветов равно удвоенному число кривых. Если в 2d версии pen содержит ‘i’, то закрашивается только область y1<y<y2, в противном случае будет закрашена и область y2<y<y1. Если pen содержит ‘#’, то рисуется только каркас. Если pen содержит ‘a’, то рисуются и сегменты между точками вне диапазона осей координат. См. также area, bars, stem. См. раздел region sample, для примеров кода и графика.
- Команда MGL: stem ydat ['stl'='']
- Команда MGL: stem xdat ydat ['stl'='']
- Команда MGL: stem xdat ydat zdat ['stl'='']
- Метод класса
mglGraph:voidStem (const mglDataA &y,const char *pen="",const char *opt="") - Метод класса
mglGraph:voidStem (const mglDataA &x,const mglDataA &y,const char *pen="",const char *opt="") - Метод класса
mglGraph:voidStem (const mglDataA &x,const mglDataA &y,const mglDataA &z,const char *pen="",const char *opt="") - Функция С:
voidmgl_stem (HMGLgr,HCDTy,const char *pen,const char *opt) - Функция С:
voidmgl_stem_xy (HMGLgr,HCDTx,HCDTy,const char *pen,const char *opt) - Функция С:
voidmgl_stem_xyz (HMGLgr,HCDTx,HCDTy,HCDTz,const char *pen,const char *opt) Функции рисуют вертикальные линии из точек до плоскости осей координат. См. также area, bars, plot, mark. См. раздел stem sample, для примеров кода и графика.
- Команда MGL: bars ydat ['stl'='']
- Команда MGL: bars xdat ydat ['stl'='']
- Команда MGL: bars xdat ydat zdat ['stl'='']
- Метод класса
mglGraph:voidBars (const mglDataA &y,const char *pen="",const char *opt="") - Метод класса
mglGraph:voidBars (const mglDataA &x,const mglDataA &y,const char *pen="",const char *opt="") - Метод класса
mglGraph:voidBars (const mglDataA &x,const mglDataA &y,const mglDataA &z,const char *pen="",const char *opt="") - Функция С:
voidmgl_bars (HMGLgr,HCDTy,const char *pen,const char *opt) - Функция С:
voidmgl_bars_xy (HMGLgr,HCDTx,HCDTy,const char *pen,const char *opt) - Функция С:
voidmgl_bars_xyz (HMGLgr,HCDTx,HCDTy,HCDTz,const char *pen,const char *opt) Функции рисуют вертикальные полосы (прямоугольники) из точек до плоскости осей координат. Строка pen может содержать:
- ‘a’ для вывода линий одной поверх другой (как при суммировании);
- ‘f’ для определения кумулятивного эффекта последовательности положительных и отрицательных значений (график типа waterfall);
- ‘F’ для использования одинаковой (минимальной) ширины полосок;
- ‘<’, ‘^’ or ‘>’ для выравнивания полосок влево, вправо или центрирования относительно их координат.
Можно использовать разные цвета для положительных и отрицательных значений если число указанных цветов равно удвоенному числу кривых для построения. Если x.nx>y.nx, то массив x задает границы полос, а не их центр. См. также barh, cones, area, stem, chart, barwidth. См. раздел bars sample, для примеров кода и графика.
- Команда MGL: barh vdat ['stl'='']
- Команда MGL: barh ydat vdat ['stl'='']
- Метод класса
mglGraph:voidBarh (const mglDataA &v,const char *pen="",const char *opt="") - Метод класса
mglGraph:voidBarh (const mglDataA &y,const mglDataA &v,const char *pen="",const char *opt="") - Функция С:
voidmgl_barh (HMGLgr,HCDTv,const char *pen,const char *opt) - Функция С:
voidmgl_barh_xy (HMGLgr,HCDTy,HCDTv,const char *pen,const char *opt) Функции рисуют горизонтальные полосы (прямоугольники) из точек до плоскости осей координат. Строка pen может содержать:
- ‘a’ для вывода линий одной поверх другой (как при суммировании);
- ‘f’ для определения кумулятивного эффекта последовательности положительных и отрицательных значений (график типа waterfall);
- ‘F’ для использования одинаковой (минимальной) ширины полосок;
- ‘<’, ‘^’ or ‘>’ для выравнивания полосок влево, вправо или центрирования относительно их координат.
Можно использовать разные цвета для положительных и отрицательных значений если число указанных цветов равно удвоенному числу кривых для построения. Если x.nx>y.nx, то массив x задает границы полос, а не их центр. См. также bars, barwidth. См. раздел barh sample, для примеров кода и графика.
- Команда MGL: cones ydat ['stl'='']
- Команда MGL: cones xdat ydat ['stl'='']
- Команда MGL: cones xdat ydat zdat ['stl'='']
- Метод класса
mglGraph:voidCones (const mglDataA &y,const char *pen="",const char *opt="") - Метод класса
mglGraph:voidCones (const mglDataA &x,const mglDataA &y,const char *pen="",const char *opt="") - Метод класса
mglGraph:voidCones (const mglDataA &x,const mglDataA &y,const mglDataA &z,const char *pen="",const char *opt="") - Функция С:
voidmgl_cones (HMGLgr,HCDTy,const char *pen,const char *opt) - Функция С:
voidmgl_cones_xy (HMGLgr,HCDTx,HCDTy,const char *pen,const char *opt) - Функция С:
voidmgl_cones_xyz (HMGLgr,HCDTx,HCDTy,HCDTz,const char *pen,const char *opt) Функции рисуют конусы из точек до плоскости осей координат. Если строка pen содержит символ ‘a’, то линии рисуются одна поверх другой. Можно использовать разные цвета для положительных и отрицательных значений если число указанных цветов равно удвоенному числу кривых для построения. Параметр pen может содержать:
- ‘@’ для рисования торцов;
- ‘#’ для сетчатой фигуры;
- ‘t’ для рисования цилиндра вместо конуса/призмы;
- ‘4’, ‘6’, ‘8’ для рисования квадратной, шестиугольной или восьмиугольной призмы вместо конуса;
- ‘<’, ‘^’ или ‘>’ для выравнивания конусов влево, вправо или по центру относительно их координат.
См. также bars, cone, barwidth. См. раздел cones sample, для примеров кода и графика.
- Команда MGL: chart adat ['col'='']
- Метод класса
mglGraph:voidChart (const mglDataA &a,const char *col="",const char *opt="") - Функция С:
voidmgl_chart (HMGLgr,HCDTa,const char *col,const char *opt) Рисует цветные полосы (пояса) для массива данных a. Число полос равно числу строк a (равно a.ny). Цвет полос поочерёдно меняется из цветов указанных в col или в палитре (см. Palette and colors). Пробел в цветах соответствует прозрачному "цвету", т.е. если col содержит пробел(ы), то соответствующая полоса не рисуется. Ширина полосы пропорциональна значению элемента в a. График строится только для массивов не содержащих отрицательных значений. Если строка col содержит ‘#’, то рисуется также чёрная граница полос. График выглядит лучше в (после вращения системы координат) и/или в полярной системе координат (становится Pie chart). См. раздел chart sample, для примеров кода и графика.
- Команда MGL: boxplot adat ['stl'='']
- Команда MGL: boxplot xdat adat ['stl'='']
- Метод класса
mglGraph:voidBoxPlot (const mglDataA &a,const char *pen="",const char *opt="") - Метод класса
mglGraph:voidBoxPlot (const mglDataA &x,const mglDataA &a,const char *pen="",const char *opt="") - Функция С:
voidmgl_boxplot (HMGLgr,HCDTa,const char *pen,const char *opt) - Функция С:
voidmgl_boxplot_xy (HMGLgr,HCDTx,HCDTa,const char *pen,const char *opt) Функции рисуют boxplot (называемый также как box-and-whisker diagram или как "ящик с усами") в точках x[i] на плоскости z = zVal (по умолчанию z равно минимальному значению оси z). Это график, компактно изображающий распределение вероятностей a[i,j] (минимум, нижний квартиль (Q1), медиана (Q2), верхний квартиль (Q3) и максимум) вдоль второго (j-го) направления. Если pen содержит ‘<’, ‘^’ или ‘>’, то полоски будут выровнены влево, вправо или центрированы относительно их координат. См. также plot, error, bars, barwidth. См. раздел boxplot sample, для примеров кода и графика.
- Команда MGL: candle vdat1 ['stl'='']
- Команда MGL: candle vdat1 vdat2 ['stl'='']
- Команда MGL: candle vdat1 ydat1 ydat2 ['stl'='']
- Команда MGL: candle vdat1 vdat2 ydat1 ydat2 ['stl'='']
- Команда MGL: candle xdat vdat1 vdat2 ydat1 ydat2 ['stl'='']
- Метод класса
mglGraph:voidCandle (const mglDataA &v1,const char *pen="",const char *opt="") - Метод класса
mglGraph:voidCandle (const mglDataA &v1,const mglDataA &v2,const char *pen="",const char *opt="") - Метод класса
mglGraph:voidCandle (const mglDataA &v1,const mglDataA &y1,const mglDataA &y2,const char *pen="",const char *opt="") - Метод класса
mglGraph:voidCandle (const mglDataA &v1,const mglDataA &v2,const mglDataA &y1,const mglDataA &y2,const char *pen="",const char *opt="") - Метод класса
mglGraph:voidCandle (const mglDataA &x,const mglDataA &v1,const mglDataA &v2,const mglDataA &y1,const mglDataA &y2,const char *pen="",const char *opt="") - Функция С:
voidmgl_candle (HMGLgr,HCDTv1,HCDTy1,HCDTy2,const char *pen,const char *opt) - Функция С:
voidmgl_candle_yv (HMGLgr,HCDTv1,HCDTv2,HCDTy1,HCDTy2,const char *pen,const char *opt) - Функция С:
voidmgl_candle_xyv (HMGLgr,HCDTx,HCDTv1,HCDTv2,HCDTy1,HCDTy2,const char *pen,const char *opt) Функции рисуют candlestick chart в точках x[i]. Этот график показывает прямоугольником ("свечой") диапазон изменения величины. Прозрачная (белая) свеча соответствует росту величины v1[i]<v2[i], чёрная – уменьшению. "Тени" показывают минимальное y1 и максимальное y2 значения. Если v2 отсутствует, то он определяется как v2[i]=v1[i+1]. Можно использовать разные цвета для растущих и падающих дней если число указанных цветов равно удвоенному числу кривых для построения. Если pen содержит ‘#’, то прозрачная свеча будет использована и при 2-цветной схеме. См. также plot, bars, ohlc, barwidth. См. раздел candle sample, для примеров кода и графика.
- Команда MGL: ohlc odat hdat ldat cdat ['stl'='']
- Команда MGL: ohlc xdat odat hdat ldat cdat ['stl'='']
- MМетод класса
mglGraph:voidOHLC (const mglDataA &o,const mglDataA &h,const mglDataA &l,const mglDataA &c,const char *pen="",const char *opt="") - Метод класса
mglGraph:voidOHLC (const mglDataA &x,const mglDataA &o,const mglDataA &h,const mglDataA &l,const mglDataA &c,const char *pen="",const char *opt="") - Функция С:
voidmgl_ohlc (HMGLgr,HCDTo,HCDTh,HCDTl,HCDTc,const char *pen,const char *opt) - Функция С:
voidmgl_ohlc_x (HMGLgr,HCDTx,HCDTo,HCDTh,HCDTl,HCDTc,const char *pen,const char *opt) Функции рисуют Open-High-Low-Close диаграмму. Этот график содержит вертикальные линии между максимальным h и минимальным l значениями, и горизонтальные линии перед/после вертикальной линии для начального o и конечного c значений процесса (обычно цены). Можно использовать разные цвета для растущих и падающих дней если число указанных цветов равно удвоенному числу кривых для построения. См. также candle, plot, barwidth. См. раздел ohlc sample, для примеров кода и графика.
- Команда MGL: error ydat yerr ['stl'='']
- Команда MGL: error xdat ydat yerr ['stl'='']
- Команда MGL: error xdat ydat xerr yerr ['stl'='']
- Метод класса
mglGraph:voidError (const mglDataA &y,const mglDataA &ey,const char *pen="",const char *opt="") - Метод класса
mglGraph:voidError (const mglDataA &x,const mglDataA &y,const mglDataA &ey,const char *pen="",const char *opt="") - Метод класса
mglGraph:voidError (const mglDataA &x,const mglDataA &y,const mglDataA &ex,const mglDataA &ey,const char *pen="",const char *opt="") - Функция С:
voidmgl_error (HMGLgr,HCDTy,HCDTey,const char *pen,const char *opt) - Функция С:
voidmgl_error_xy (HMGLgr,HCDTx,HCDTy,HCDTey,const char *pen,const char *opt) - Функция С:
voidmgl_error_exy (HMGLgr,HCDTx,HCDTy,HCDTex,HCDTey,const char *pen,const char *opt) Функции рисуют размер ошибки {ex[i], ey[i]} в точках {x[i], y[i]} на плоскости z = zVal (по умолчанию z равно минимальному значению оси z). Такой график полезен для отображения ошибки эксперимента, вычислений и пр. Если pen содержит ‘@’, то будут использованы большие полупрозрачные маркеры. См. также plot, mark. См. раздел error sample, для примеров кода и графика.
- Команда MGL: mark ydat rdat ['stl'='']
- Команда MGL: mark xdat ydat rdat ['stl'='']
- Команда MGL: mark xdat ydat zdat rdat ['stl'='']
- Метод класса
mglGraph:voidMark (const mglDataA &y,const mglDataA &r,const char *pen="",const char *opt="") - Метод класса
mglGraph:voidMark (const mglDataA &x,const mglDataA &y,const mglDataA &r,const char *pen="",const char *opt="") - Метод класса
mglGraph:voidMark (const mglDataA &x,const mglDataA &y,const mglDataA &z,const mglDataA &r,const char *pen="",const char *opt="") - Функция С:
voidmgl_mark_y (HMGLgr,HCDTy,HCDTr,const char *pen,const char *opt) - Функция С:
voidmgl_mark_xy (HMGLgr,HCDTx,HCDTy,HCDTr,const char *pen,const char *opt) - Функция С:
voidmgl_mark_xyz (HMGLgr,HCDTx,HCDTy,HCDTz,HCDTr,const char *pen,const char *opt) Функции рисуют маркеры размером r[i]*marksize (см. Default sizes) в точках {x[i], y[i], z[i]}. Для рисования маркеров одинакового размера можно использовать функцию plot с невидимой линией (со стилем содержащим ‘ ’). Для маркеров с размером как у координат можно использовать error со стилем ‘@’. См. также plot, textmark, error, stem, meshnum. См. раздел mark sample, для примеров кода и графика.
- Команда MGL: textmark ydat 'txt' ['stl'='']
- Команда MGL: textmark ydat rdat 'txt' ['stl'='']
- Команда MGL: textmark xdat ydat rdat 'txt' ['stl'='']
- Команда MGL: textmark xdat ydat zdat rdat 'txt' ['stl'='']
- Метод класса
mglGraph:voidTextMark (const mglDataA &y,const char *txt,const char *fnt="",const char *opt="") - Метод класса
mglGraph:voidTextMark (const mglDataA &y,const wchar_t *txt,const char *fnt="",const char *opt="") - Метод класса
mglGraph:voidTextMark (const mglDataA &y,const mglDataA &r,const char *txt,const char *fnt="",const char *opt="") - Метод класса
mglGraph:voidTextMark (const mglDataA &y,const mglDataA &r,const wchar_t *txt,const char *fnt="",const char *opt="") - Метод класса
mglGraph:voidTextMark (const mglDataA &x,const mglDataA &y,const mglDataA &r,const char *txt,const char *fnt="",const char *opt="") - Метод класса
mglGraph:voidTextMark (const mglDataA &x,const mglDataA &y,const mglDataA &r,const wchar_t *txt,const char *fnt="",const char *opt="") - Метод класса
mglGraph:voidTextMark (const mglDataA &x,const mglDataA &y,const mglDataA &z,const mglDataA &r,const char *txt,const char *fnt="",const char *opt="") - Метод класса
mglGraph:voidTextMark (const mglDataA &x,const mglDataA &y,const mglDataA &z,const mglDataA &r,const wchar_t *txt,const char *fnt="",const char *opt="") - Функция С:
voidmgl_textmark (HMGLgr,HCDTy,const char *txt,const char *fnt,const char *opt) - Функция С:
voidmgl_textmarkw (HMGLgr,HCDTy,const wchar_t *txt,const char *fnt,const char *opt) - Функция С:
voidmgl_textmark_yr (HMGLgr,HCDTy,HCDTr,const char *txt,const char *fnt,const char *opt) - Функция С:
voidmgl_textmarkw_yr (HMGLgr,HCDTy,HCDTr,const wchar_t *txt,const char *fnt,const char *opt) - Функция С:
voidmgl_textmark_xyr (HMGLgr,HCDTx,HCDTy,HCDTr,const char *txt,const char *fnt,const char *opt) - Функция С:
voidmgl_textmarkw_xyr (HMGLgr,HCDTx,HCDTy,HCDTr,const wchar_t *txt,const char *fnt,const char *opt) - Функция С:
voidmgl_textmark_xyzr (HMGLgr,HCDTx,HCDTy,HCDTz,HCDTr,const char *txt,const char *fnt,const char *opt) - Функция С:
voidmgl_textmarkw_xyzr (HMGLgr,HCDTx,HCDTy,HCDTz,HCDTr,const wchar_t *txt,const char *fnt,const char *opt) Функции рисуют текст txt как маркер с размером пропорциональным r[i]*marksize в точках {x[i], y[i], z[i]}. См. также plot, mark, stem, meshnum. См. раздел textmark sample, для примеров кода и графика.
- Команда MGL: label ydat 'txt' ['stl'='']
- Команда MGL: label xdat ydat 'txt' ['stl'='']
- Команда MGL: label xdat ydat zdat 'txt' ['stl'='']
- Метод класса
mglGraph:voidLabel (const mglDataA &y,const char *txt,const char *fnt="",const char *opt="") - Метод класса
mglGraph:voidLabel (const mglDataA &y,const wchar_t *txt,const char *fnt="",const char *opt="") - Метод класса
mglGraph:voidLabel (const mglDataA &x,const mglDataA &y,const char *txt,const char *fnt="",const char *opt="") - Метод класса
mglGraph:voidLabel (const mglDataA &x,const mglDataA &y,const wchar_t *txt,const char *fnt="",const char *opt="") - Метод класса
mglGraph:voidLabel (const mglDataA &x,const mglDataA &y,const mglDataA &z,const char *txt,const char *fnt="",const char *opt="") - Метод класса
mglGraph:voidLabel (const mglDataA &x,const mglDataA &y,const mglDataA &z,const wchar_t *txt,const char *fnt="",const char *opt="") - Функция С:
voidmgl_label (HMGLgr,HCDTy,const char *txt,const char *fnt,const char *opt) - Функция С:
voidmgl_labelw (HMGLgr,HCDTy,const wchar_t *txt,const char *fnt,const char *opt) - Функция С:
voidmgl_label_xy (HMGLgr,HCDTx,HCDTy,const char *txt,const char *fnt,const char *opt) - Функция С:
voidmgl_labelw_xy (HMGLgr,HCDTx,HCDTy,const wchar_t *txt,const char *fnt,const char *opt) - Функция С:
voidmgl_label_xyz (HMGLgr,HCDTx,HCDTy,HCDTz,const char *txt,const char *fnt,const char *opt) - Функция С:
voidmgl_labelw_xyz (HMGLgr,HCDTx,HCDTy,HCDTz,const wchar_t *txt,const char *fnt,const char *opt) Функции выводят текстовую строку txt в точках {x[i], y[i], z[i]}. Если строка txt содержит ‘%x’, ‘%y’, ‘%z’ или ‘%n’, то они будут заменены на значения соответствующих координат или на номер точки. Строка fnt может содержать:
- стиль текста Font styles;
- ‘f’ для вывода чисел в фиксированном формате;
- ‘E’ для вывода ‘E’ вместо ‘e’;
- ‘F’ для вывода в формате LaTeX;
- ‘+’ для вывода ‘+’ для положительных чисел;
- ‘-’ для вывода обычного ‘-’;
- ‘0123456789’ для задания точности при выводе чисел.
См. также plot, mark, textmark, table. См. раздел label sample, для примеров кода и графика.
- Команда MGL: table vdat 'txt' ['stl'='#']
- Команда MGL: table x y vdat 'txt' ['stl'='#']
- Метод класса
mglGraph:voidTable (const mglDataA &val,const char *txt,const char *fnt="",const char *opt="") - Метод класса
mglGraph:voidTable (const mglDataA &val,const wchar_t *txt,const char *fnt="",const char *opt="") - Метод класса
mglGraph:voidTable (mrealx,mrealy,const mglDataA &val,const char *txt,const char *fnt="",const char *opt="") - Метод класса
mglGraph:voidTable (mrealx,mrealy,const mglDataA &val,const wchar_t *txt,const char *fnt="",const char *opt="") - Функция С:
voidmgl_table (HMGLgr,mrealx,mrealy,HCDTval,const char *txt,const char *fnt,const char *opt) - Функция С:
voidmgl_tablew (HMGLgr,mrealx,mrealy,HCDTval,const wchar_t *txt,const char *fnt,const char *opt) Рисует таблицу значений массива val с заголовками txt (разделенными символом новой строки ‘\n’) в точке {x, y} (по умолчанию {0,0}) относительно текущего subplot. Строка fnt может содержать:
- стиль текста Font styles;
- ‘#’ для рисования границ ячеек;
- ‘=’ для одинаковой ширины всех ячеек;
- ‘|’ для ограничения ширины таблицы шириной subplot (эквивалентно опции ‘value 1’);
- ‘f’ для вывода чисел в фиксированном формате;
- ‘E’ для вывода ‘E’ вместо ‘e’;
- ‘F’ для вывода в формате LaTeX;
- ‘+’ для вывода ‘+’ для положительных чисел;
- ‘-’ для вывода обычного ‘-’;
- ‘0123456789’ для задания точности при выводе чисел.
Опция
valueзадает ширину таблицы (по умолчанию 1). См. также plot, label. См. раздел table sample, для примеров кода и графика.
- Команда MGL: iris dats 'ids' ['stl'='']
- Команда MGL: iris dats rngs 'ids' ['stl'='']
- Метод класса
mglGraph:voidIris (const mglDataA &dats,const char *ids,const char *stl="",const char *opt="") - Метод класса
mglGraph:voidIris (const mglDataA &dats,const wchar_t *ids,const char *stl="",const char *opt="") - Метод класса
mglGraph:voidIris (const mglDataA &dats,const mglDataA &rngs,const char *ids,const char *stl="",const char *opt="") - Метод класса
mglGraph:voidIris (const mglDataA &dats,const mglDataA &rngs,const wchar_t *ids,const char *stl="",const char *opt="") - Функция С:
voidmgl_iris_1 (HMGLgr,HCDTdats,const char *ids,const char *stl,const char *opt) - Функция С:
voidmgl_irisw_1 (HMGLgr,HCDTdats,const wchar_t *ids,const char *stl,const char *opt) - Функция С:
voidmgl_iris (HMGLgr,HCDTdats,HCDTrngs,const char *ids,const char *stl,const char *opt) - Функция С:
voidmgl_irisw (HMGLgr,HCDTdats,HCDTrngs,const wchar_t *ids,const char *stl,const char *opt) Рисует Ирисы Фишера для определения зависимостей данных dats друг от друга (см. http://en.wikipedia.org/wiki/Iris_flower_data_set). Массив rngs размером 2*dats.nx задает диапазон изменения осей для каждой из колонки. Строка ids содержит имена колонок данных, разделенных символом ‘;’. Опция
valueзадает размер текста для имен данных. На график можно добавить новый набор данных если указать тот же размер rngs и использовать пустую строку имен ids. См. также plot. См. раздел iris sample, для примеров кода и графика.
- Команда MGL: tube ydat rdat ['stl'='']
- Команда MGL: tube ydat
rval['stl'=''] - Команда MGL: tube xdat ydat rdat ['stl'='']
- Команда MGL: tube xdat ydat
rval['stl'=''] - Команда MGL: tube xdat ydat zdat rdat ['stl'='']
- Команда MGL: tube xdat ydat zdat
rval['stl'=''] - Метод класса
mglGraph:voidTube (const mglDataA &y,const mglDataA &r,const char *pen="",const char *opt="") - Метод класса
mglGraph:voidTube (const mglDataA &y,mrealr,const char *pen="",const char *opt="") - Метод класса
mglGraph:voidTube (const mglDataA &x,const mglDataA &y,const mglDataA &r,const char *pen="",const char *opt="") - Метод класса
mglGraph:voidTube (const mglDataA &x,const mglDataA &y,mrealr,const char *pen="",const char *opt="") - Метод класса
mglGraph:voidTube (const mglDataA &x,const mglDataA &y,const mglDataA &z,const mglDataA &r,const char *pen="",const char *opt="") - Метод класса
mglGraph:voidTube (const mglDataA &x,const mglDataA &y,const mglDataA &z,mrealr,const char *pen="",const char *opt="") - Функция С:
voidmgl_tube_r (HMGLgr,HCDTy,HCDTr,const char *pen,const char *opt) - Функция С:
voidmgl_tube (HMGLgr,HCDTy,mrealr,const char *pen,const char *opt) - Функция С:
voidmgl_tube_xyr (HMGLgr,HCDTx,HCDTy,HCDTr,const char *pen,const char *opt) - Функция С:
voidmgl_tube_xy (HMGLgr,HCDTx,HCDTy,mrealr,const char *pen,const char *opt) - Функция С:
voidmgl_tube_xyzr (HMGLgr,HCDTx,HCDTy,HCDTz,HCDTr,const char *pen,const char *opt) - Функция С:
voidmgl_tube_xyz (HMGLgr,HCDTx,HCDTy,HCDTz,mrealr,const char *pen,const char *opt) Функции рисуют трубу радиуса r[i] вдоль кривой между точками {x[i], y[i], z[i]}. Опция
valueчисло сегментов в поперечном сечении (по умолчанию 25). См. также plot. См. раздел tube sample, для примеров кода и графика.
- Команда MGL: torus rdat zdat ['stl'='']
- Метод класса
mglGraph:voidTorus (const mglDataA &r,const mglDataA &z,const char *pen="",const char *opt="") - Функция С:
voidmgl_torus (HMGLgr,HCDTr,HCDTz,const char *pen,const char *opt) Функции рисуют поверхность вращения кривой {r, z} относительно оси. Если строка pen содержит ‘x’ или ‘z’, то ось вращения будет выбрана в указанном направлении (по умолчанию вдоль оси y). Если sch содержит ‘#’, то рисуется сетчатая поверхность. Если sch содержит ‘.’, то рисуется поверхность из точек. См. также plot, axial. См. раздел torus sample, для примеров кода и графика.
- Команда MGL: lamerey
x0ydat ['stl'=''] - Команда MGL: lamerey
x0'y(x)' ['stl'=''] - Метод класса
mglGraph:voidLamerey (doublex0,const mglDataA &y,const char *stl="",const char *opt="") - Метод класса
mglGraph:voidLamerey (doublex0,const char *y,const char *stl="",const char *opt="") - Функция С:
voidmgl_lamerey_dat (HMGLgr,doublex0,HCDTy,const char *stl,const char *opt) - Функция С:
voidmgl_lamerey_str (HMGLgr,doublex0,const char *y,const char *stl,const char *opt) Функции рисуют диаграмму Ламерея для точечного отображения x_new = y(x_old) начиная с точки x0. Строка stl может содержать стиль линии, символ ‘v’ для стрелок, символ ‘~’ для исключения первого сегмента. Опция
valueзадает число сегментов для рисования (по умолчанию 20). См. также plot, fplot, bifurcation, pmap. См. раздел lamerey sample, для примеров кода и графика.
- Команда MGL: bifurcation
dxydat ['stl'=''] - Команда MGL: bifurcation
dx'y(x)' ['stl'=''] - Метод класса
mglGraph:voidBifurcation (doubledx,const mglDataA &y,const char *stl="",const char *opt="") - Метод класса
mglGraph:voidBifurcation (doubledx,const char *y,const char *stl="",const char *opt="") - Функция С:
voidmgl_bifurcation_dat (HMGLgr,doubledx,HCDTy,const char *stl,const char *opt) - Функция С:
voidmgl_bifurcation_str (HMGLgr,doubledx,const char *y,const char *stl,const char *opt) Функции рисуют бифуркационную диаграмму (диаграмму удвоения периода) для точечного отображения x_new = y(x_old). Параметр dx задает точность по оси x. Строка stl задает цвет. Опция
valueзадает число учитываемых стационарных точек (по умолчанию 1024). См. также plot, fplot, lamerey. См. раздел bifurcation sample, для примеров кода и графика.
- Команда MGL: pmap ydat sdat ['stl'='']
- Команда MGL: pmap xdat ydat sdat ['stl'='']
- Команда MGL: pmap xdat ydat zdat sdat ['stl'='']
- Метод класса
mglGraph:voidPmap (const mglDataA &y,const mglDataA &s,const char *stl="",const char *opt="") - Метод класса
mglGraph:voidPmap (const mglDataA &x,const mglDataA &y,const mglDataA &s,const char *stl="",const char *opt="") - Метод класса
mglGraph:voidPmap (const mglDataA &x,const mglDataA &y,const mglDataA &z,const mglDataA &s,const char *stl="",const char *opt="") - Функция С:
voidmgl_pmap (HMGLgr,HMDTy,HCDTs,const char *stl,const char *opt) - Функция С:
voidmgl_pmap_xy (HMGLgr,HCDTx,HMDTy,HCDTs,const char *stl,const char *opt) - Функция С:
voidmgl_pmap_xyz (HMGLgr,HCDTx,HMDTy,HCDTz,HCDTs,const char *stl,const char *opt) Функции рисуют отображение Пуанкаре для кривой {x, y, z} при условии s=0. Проще говоря, рисуются точки пересечения кривой и поверхности. Строка stl задает стиль маркеров. См. также plot, mark, lamerey. См. раздел pmap sample, для примеров кода и графика.
Next: 3D plotting, Previous: 1D plotting, Up: MathGL core [Contents][Index]
4.12 2D графики
Эти функции строят графики для двумерных (2D) массивов. Двумерными считаются массивы, зависящие только от двух параметров (индексов) подобно матрице f(x_i,y_j), i=1...n, j=1...m. По умолчанию (если отсутствуют) значения x, y равно распределены в диапазоне осей координат. Младшие размерности массивов x, y, z должны быть одинаковы x.nx=z.nx && y.nx=z.ny или x.nx=y.nx=z.nx && x.ny=y.ny=z.ny. Массивы x и y могут быть векторами (не матрицами как z). График строится для каждого z среза данных. Строка sch задает цветовую схему (см. Color scheme). Строка opt задает опции графика (см. Command options).
- Команда MGL: surf zdat ['sch'='']
- Команда MGL: surf xdat ydat zdat ['sch'='']
- Метод класса
mglGraph:voidSurf (const mglDataA &z,const char *sch="",const char *opt="") - Метод класса
mglGraph:voidSurf (const mglDataA &x,const mglDataA &y,const mglDataA &z,const char *sch="",const char *opt="") - Функция С:
voidmgl_surf (HMGLgr,HCDTz,const char *sch,const char *opt) - Функция С:
voidmgl_surf_xy (HMGLgr,HCDTx,HCDTy,HCDTz,const char *sch,const char *opt) Рисует параметрически заданную поверхность {x[i,j], y[i,j], z[i,j]}. Если sch содержит ‘#’, то рисуется сетка на поверхности. Если sch содержит ‘.’, то рисуется поверхность из точек. См. также mesh, dens, belt, tile, boxs, surfc, surfa. См. раздел surf sample, для примеров кода и графика.
- Команда MGL: mesh zdat ['sch'='']
- Команда MGL: mesh xdat ydat zdat ['sch'='']
- Метод класса
mglGraph:voidMesh (const mglDataA &z,const char *sch="",const char *opt="") - Метод класса
mglGraph:voidMesh (const mglDataA &x,const mglDataA &y,const mglDataA &z,const char *sch="",const char *opt="") - Функция С:
voidmgl_mesh (HMGLgr,HCDTz,const char *sch,const char *opt) - Функция С:
voidmgl_mesh_xy (HMGLgr,HCDTx,HCDTy,HCDTz,const char *sch,const char *opt) Рисует сетчатую поверхность, заданную параметрически {x[i,j], y[i,j], z[i,j]}. См. также surf, fall, meshnum, cont, tens. См. раздел mesh sample, для примеров кода и графика.
- Команда MGL: fall zdat ['sch'='']
- Команда MGL: fall xdat ydat zdat ['sch'='']
- Метод класса
mglGraph:voidFall (const mglDataA &z,const char *sch="",const char *opt="") - Метод класса
mglGraph:voidFall (const mglDataA &x,const mglDataA &y,const mglDataA &z,const char *sch="",const char *opt="") - Функция С:
voidmgl_fall (HMGLgr,HCDTz,const char *sch,const char *opt) - Функция С:
voidmgl_fall_xy (HMGLgr,HCDTx,HCDTy,HCDTz,const char *sch,const char *opt) Рисует водопад для параметрически заданной поверхности {x[i,j], y[i,j], z[i,j]}. График удобен для построения нескольких кривых, сдвинутых вглубь друг относительно друга. Если sch содержит ‘x’, то линии рисуются вдоль оси x, иначе (по умолчанию) вдоль оси y. См. также belt, mesh, tens, meshnum. См. раздел fall sample, для примеров кода и графика.
- Команда MGL: belt zdat ['sch'='']
- Команда MGL: belt xdat ydat zdat ['sch'='']
- Метод класса
mglGraph:voidBelt (const mglDataA &z,const char *sch="",const char *opt="") - Метод класса
mglGraph:voidBelt (const mglDataA &x,const mglDataA &y,const mglDataA &z,const char *sch="",const char *opt="") - Функция С:
voidmgl_belt (HMGLgr,HCDTz,const char *sch,const char *opt) - Функция С:
voidmgl_belt_xy (HMGLgr,HCDTx,HCDTy,HCDTz,const char *sch,const char *opt) Рисует ленточки для параметрически заданной поверхности {x[i,j], y[i,j], z[i,j]}. График может использоваться как 3d обобщение графика plot. Если sch содержит ‘x’, то ленточки рисуются вдоль оси x, иначе (по умолчанию) вдоль оси y. См. также fall, surf, beltc, plot, meshnum. См. раздел belt sample, для примеров кода и графика.
- Команда MGL: boxs zdat ['sch'='']
- Команда MGL: boxs xdat ydat zdat ['sch'='']
- Метод класса
mglGraph:voidBoxs (const mglDataA &z,const char *sch="",const char *opt="") - Метод класса
mglGraph:voidBoxs (const mglDataA &x,const mglDataA &y,const mglDataA &z,const char *sch="",const char *opt="") - Функция С:
voidmgl_boxs (HMGLgr,HCDTz,const char *sch,const char *opt) - Функция С:
voidmgl_boxs_xy (HMGLgr,HCDTx,HCDTy,HCDTz,const char *sch,const char *opt) Рисует вертикальные ящики для параметрически заданной поверхности {x[i,j], y[i,j], z[i,j]}. См. также surf, dens, tile, step. См. раздел boxs sample, для примеров кода и графика.
- Команда MGL: tile zdat ['sch'='']
- Команда MGL: tile xdat ydat zdat ['sch'='']
- Команда MGL: tile xdat ydat zdat cdat ['sch'='']
- Метод класса
mglGraph:voidTile (const mglDataA &z,const char *sch="",const char *opt="") - Метод класса
mglGraph:voidTile (const mglDataA &x,const mglDataA &y,const mglDataA &z,const char *sch="",const char *opt="") - Метод класса
mglGraph:voidTile (const mglDataA &x,const mglDataA &y,const mglDataA &z,const mglDataA &c,const char *sch="",const char *opt="") - Функция С:
voidmgl_tile (HMGLgr,HCDTz,const char *sch,const char *opt) - Функция С:
voidmgl_tile_xy (HMGLgr,HCDTx,HCDTy,HCDTz,const char *sch,const char *opt) - Функция С:
voidmgl_tile_xyc (HMGLgr,HCDTx,HCDTy,HCDTz,HCDTc,const char *sch,const char *opt) Рисует плитки для параметрически заданной поверхности {x[i,j], y[i,j], z[i,j]} с цветом, заданным массивом c[i,j]. Если строка sch содержит стиль ‘x’ или ‘y’, то плитки будут ориентированы перпендикулярно x- или y-оси. График может использоваться как 3d обобщение step. См. также surf, boxs, step, tiles. См. раздел tile sample, для примеров кода и графика.
- Команда MGL: dens zdat ['sch'='']
- Команда MGL: dens xdat ydat zdat ['sch'='']
- Метод класса
mglGraph:voidDens (const mglDataA &z,const char *sch="",const char *opt="",mrealzVal=NAN) - Метод класса
mglGraph:voidDens (const mglDataA &x,const mglDataA &y,const mglDataA &z,const char *sch="",const char *opt="",mrealzVal=NAN) - Функция С:
voidmgl_dens (HMGLgr,HCDTz,const char *sch,const char *opt) - Функция С:
voidmgl_dens_xy (HMGLgr,HCDTx,HCDTy,HCDTz,const char *sch,const char *opt) Рисует график плотности для параметрически заданной поверхности {x[i,j], y[i,j], z[i,j]} при z равном минимальному значению оси z. Если sch содержит ‘#’, то рисуется сетка. Если sch содержит ‘.’, то рисуется поверхность из точек. См. также surf, cont, contf, boxs, tile,
dens[xyz]. См. раздел dens sample, для примеров кода и графика.
- Команда MGL: cont vdat zdat ['sch'='']
- Команда MGL: cont vdat xdat ydat zdat ['sch'='']
- Метод класса
mglGraph:voidCont (const mglDataA &v,const mglDataA &z,const char *sch="",const char *opt="") - Метод класса
mglGraph:voidCont (const mglDataA &v,const mglDataA &x,const mglDataA &y,const mglDataA &z,const char *sch="",const char *opt="") - Функция С:
voidmgl_cont__val (HMGLgr,HCDTv,HCDTz,const char *sch,const char *opt) - Функция С:
voidmgl_cont_xy_val (HMGLgr,HCDTv,HCDTx,HCDTy,HCDTz,const char *sch,const char *opt) Рисует линии уровня для параметрически заданной поверхности {x[i,j], y[i,j], z[i,j]} при z=v[k] или при z равном минимальному значению оси z если sch содержит ‘_’. Линии уровня рисуются для z[i,j]=v[k]. Если sch содержит ‘t’ или ‘T’, то значения v[k] будут выведены вдоль контуров над (или под) кривой. См. также dens, contf, contd, axial,
cont[xyz]. См. раздел cont sample, для примеров кода и графика.
- Команда MGL: cont zdat ['sch'='']
- Команда MGL: cont xdat ydat zdat ['sch'='']
- Метод класса
mglGraph:voidCont (const mglDataA &z,const char *sch="",const char *opt="") - Метод класса
mglGraph:voidCont (const mglDataA &x,const mglDataA &y,const mglDataA &z,const char *sch="",const char *opt="") - Функция С:
voidmgl_cont (HMGLgr,HCDTz,const char *sch,const char *opt) - Функция С:
voidmgl_cont_xy (HMGLgr,HCDTx,HCDTy,HCDTz,const char *sch,const char *opt) Как предыдущий с вектором v из num элементов равно распределенных в диапазоне изменения цвета. Здесь num равен значению параметра
valueв опциях opt (по умолчанию 7). Если sch содержит ‘.’, то будут строится только контуры по уровням седловых точек.
- Команда MGL: contf vdat zdat ['sch'='']
- Команда MGL: contf vdat xdat ydat zdat ['sch'='']
- Метод класса
mglGraph:voidContF (const mglDataA &v,const mglDataA &z,const char *sch="",const char *opt="") - Метод класса
mglGraph:voidContF (const mglDataA &v,const mglDataA &x,const mglDataA &y,const mglDataA &z,const char *sch="",const char *opt="") - Функция С:
voidmgl_contf_val (HMGLgr,HCDTv,HCDTz,const char *sch,const char *opt) - Функция С:
voidmgl_contf_xy_val (HMGLgr,HCDTv,HCDTx,HCDTy,HCDTz,const char *sch,const char *opt) Рисует закрашенные линии (контуры) уровня для параметрически заданной поверхности {x[i,j], y[i,j], z[i,j]} при z=v[k] или при z равном минимальному значению оси z если sch содержит ‘_’. Линии уровня рисуются для z[i,j]=v[k]. См. также dens, cont, contd,
contf[xyz]. См. раздел contf sample, для примеров кода и графика.
- Команда MGL: contf zdat ['sch'='']
- Команда MGL: contf xdat ydat zdat ['sch'='']
- Метод класса
mglGraph:voidContF (const mglDataA &z,const char *sch="",const char *opt="") - Метод класса
mglGraph:voidContF (const mglDataA &x,const mglDataA &y,const mglDataA &z,const char *sch="",const char *opt="") - Функция С:
voidmgl_contf (HMGLgr,HCDTz,const char *sch,const char *opt) - Функция С:
voidmgl_contf_xy (HMGLgr,HCDTx,HCDTy,HCDTz,const char *sch,const char *opt) Как предыдущий с вектором v из num элементов равно распределенных в диапазоне изменения цвета. Здесь num равен значению параметра
valueв опциях opt (по умолчанию 7).
- Команда MGL: contd vdat zdat ['sch'='']
- Команда MGL: contd vdat xdat ydat zdat ['sch'='']
- Метод класса
mglGraph:voidContD (const mglDataA &v,const mglDataA &z,const char *sch="",const char *opt="") - Метод класса
mglGraph:voidContD (const mglDataA &v,const mglDataA &x,const mglDataA &y,const mglDataA &z,const char *sch="",const char *opt="") - Функция С:
voidmgl_contd_val (HMGLgr,HCDTv,HCDTz,const char *sch,const char *opt) - Функция С:
voidmgl_contd_xy_val (HMGLgr,HCDTv,HCDTx,HCDTy,HCDTz,const char *sch,const char *opt) Рисует закрашенные линии (контуры) уровня для параметрически заданной поверхности {x[i,j], y[i,j], z[i,j]} при z=v[k] или при z равном минимальному значению оси z если sch содержит ‘_’. Линии уровня рисуются для z[i,j]=v[k]. Строка sch задает цвета контуров: цвет k-го контура определяется как k-ый цвет строки. См. также dens, cont, contf. См. раздел contd sample, для примеров кода и графика.
- Команда MGL: contd zdat ['sch'='']
- Команда MGL: contd xdat ydat zdat ['sch'='']
- Метод класса
mglGraph:voidContD (const mglDataA &z,const char *sch="",const char *opt="") - Метод класса
mglGraph:voidContD (const mglDataA &x,const mglDataA &y,const mglDataA &z,const char *sch="",const char *opt="") - Функция С:
voidmgl_contd (HMGLgr,HCDTz,const char *sch,const char *opt) - Функция С:
voidmgl_contd_xy (HMGLgr,HCDTx,HCDTy,HCDTz,const char *sch,const char *opt) Как предыдущий с вектором v из num элементов равно распределенных в диапазоне изменения цвета. Здесь num равен значению параметра
valueв опциях opt (по умолчанию 7).
- Команда MGL: contp vdat xdat ydat zdat adat ['sch'='']
- Метод класса
mglGraph:voidContP (const mglDataA &v,const mglDataA &x,const mglDataA &y,const mglDataA &z,const mglDataA &a,const char *sch="",const char *opt="") - Функция С:
voidmgl_contp_val (HMGLgr,HCDTv,HCDTx,HCDTy,HCDTz,HCDTa,const char *sch,const char *opt) Рисует линии уровня для параметрически заданной поверхности {x[i,j], y[i,j], z[i,j]}. Линии уровня рисуются для a[i,j]=v[k]. Если sch содержит ‘t’ или ‘T’, то значения v[k] будут выведены вдоль контуров над (или под) кривой. Если sch содержит ‘f’, то контуры будут закрашены. См. также cont, contf, surfc,
cont[xyz].
- Команда MGL: contp xdat ydat zdat adat ['sch'='']
- Метод класса
mglGraph:voidContP (const mglDataA &x,const mglDataA &y,const mglDataA &z,const mglDataA &a,const char *sch="",const char *opt="") - Функция С:
voidmgl_contp (HMGLgr,HCDTx,HCDTy,HCDTz,HCDTa,const char *sch,const char *opt) Как предыдущий с вектором v из num элементов равно распределенных в диапазоне изменения цвета. Здесь num равен значению параметра
valueв опциях opt (по умолчанию 7).
- Команда MGL: contv vdat zdat ['sch'='']
- Команда MGL: contv vdat xdat ydat zdat ['sch'='']
- Метод класса
mglGraph:voidContV (const mglDataA &v,const mglDataA &z,const char *sch="",const char *opt="") - Метод класса
mglGraph:voidContV (const mglDataA &v,const mglDataA &x,const mglDataA &y,const mglDataA &z,const char *sch="",const char *opt="") - Функция С:
voidmgl_contv_val (HMGLgr,HCDTv,HCDTz,const char *sch,const char *opt) - Функция С:
voidmgl_contv_xy_val (HMGLgr,HCDTv,HCDTx,HCDTy,HCDTz,const char *sch,const char *opt) Рисует вертикальные цилиндры от линий уровня для параметрически заданной поверхности {x[i,j], y[i,j], z[i,j]} при z=v[k] или при z равном минимальному значению оси z если sch содержит ‘_’. Линии уровня рисуются для z[i,j]=v[k]. См. также cont, contf. См. раздел contv sample, для примеров кода и графика.
- Команда MGL: contv zdat ['sch'='']
- Команда MGL: contv xdat ydat zdat ['sch'='']
- Метод класса
mglGraph:voidContV (const mglDataA &z,const char *sch="",const char *opt="") - Метод класса
mglGraph:voidContV (const mglDataA &x,const mglDataA &y,const mglDataA &z,const char *sch="",const char *opt="") - Функция С:
voidmgl_contv (HMGLgr,HCDTz,const char *sch,const char *opt) - Функция С:
voidmgl_contv_xy (HMGLgr,HCDTx,HCDTy,HCDTz,const char *sch,const char *opt) Как предыдущий с вектором v из num элементов равно распределенных в диапазоне изменения цвета. Здесь num равен значению параметра
valueв опциях opt (по умолчанию 7).
- Команда MGL: axial vdat zdat ['sch'='']
- Команда MGL: axial vdat xdat ydat zdat ['sch'='']
- Метод класса
mglGraph:voidAxial (const mglDataA &v,const mglDataA &z,const char *sch="",const char *opt="") - Метод класса
mglGraph:voidAxial (const mglDataA &v,const mglDataA &x,const mglDataA &y,const mglDataA &z,const char *sch="",const char *opt="") - Функция С:
voidmgl_axial_val (HMGLgr,HCDTv,HCDTz,const char *sch,const char *opt) - Функция С:
voidmgl_axial_xy_val (HMGLgr,HCDTv,HCDTx,HCDTy,HCDTz,const char *sch,const char *opt) Рисует поверхность вращения линии уровня для параметрически заданной поверхности {x[i,j], y[i,j], z[i,j]}. Линии уровня рисуются для z[i,j]=v[k]. Если sch содержит ‘#’, то рисуется сетчатая поверхность. Если sch содержит ‘.’, то рисуется поверхность из точек. Если строка содержит символы ‘x’ или ‘z’, то ось вращения устанавливается в указанное направление (по умолчанию вдоль ‘y’). См. также cont, contf, torus, surf3. См. раздел axial sample, для примеров кода и графика.
- Команда MGL: axial zdat ['sch'='']
- Команда MGL: axial xdat ydat zdat ['sch'='']
- Метод класса
mglGraph:voidAxial (const mglDataA &z,const char *sch="",const char *opt="",intnum=3) - Метод класса
mglGraph:voidAxial (const mglDataA &x,const mglDataA &y,const mglDataA &z,const char *sch="",const char *opt="",intnum=3) - Функция С:
voidmgl_axial (HMGLgr,HCDTz,const char *sch,const char *opt) - Функция С:
voidmgl_axial_xy (HMGLgr,HCDTx,HCDTy,HCDTz,const char *sch,const char *opt) Как предыдущий с вектором v из num элементов равно распределенных в диапазоне изменения цвета. Здесь num равен значению параметра
valueв опциях opt (по умолчанию 3).
- Команда MGL: grid2 zdat ['sch'='']
- Команда MGL: grid2 xdat ydat zdat ['sch'='']
- Метод класса
mglGraph:voidGrid (const mglDataA &z,const char *sch="",const char *opt="") - Метод класса
mglGraph:voidGrid (const mglDataA &x,const mglDataA &y,const mglDataA &z,const char *sch="",const char *opt="") - Функция С:
voidmgl_grid (HMGLgr,HCDTz,const char *sch,const char *opt) - Функция С:
voidmgl_grid_xy (HMGLgr,HCDTx,HCDTy,HCDTz,const char *sch,const char *opt) Рисует плоскую сету для параметрически заданной поверхности {x[i,j], y[i,j], z[i,j]} при z равном минимальному значению оси z. См. также dens, cont, contf, grid3, meshnum.
Next: Dual plotting, Previous: 2D plotting, Up: MathGL core [Contents][Index]
4.13 3D графики
Эти функции строят графики для трехмерных (3D) массивов. Трёхмерными считаются массивы, зависящие от трёх параметров (индексов) подобно матрице f(x_i,y_j,z_k), i=1...n, j=1...m, k=1...l. По умолчанию (если отсутствуют) значения x, y, z равно распределены в диапазоне осей координат. Младшие размерности массивов x, y, z должны быть одинаковы x.nx=a.nx && y.nx=a.ny && z.nz=a.nz или x.nx=y.nx=z.nx=a.nx && x.ny=y.ny=z.ny=a.ny && x.nz=y.nz=z.nz=a.nz. Массивы x, y и z могут быть векторами (не матрицами как a). Строка sch задает цветовую схему (см. Color scheme). Строка opt задает опции графика (см. Command options).
- Команда MGL: surf3 adat
val['sch'=''] - Команда MGL: surf3 xdat ydat zdat adat
val['sch'=''] - Метод класса
mglGraph:voidSurf3 (mrealval,const mglDataA &a,const char *sch="",const char *opt="") - Метод класса
mglGraph:voidSurf3 (mrealval,const mglDataA &x,const mglDataA &y,const mglDataA &z,const mglDataA &a,const char *sch="",const char *opt="") - Функция С:
voidmgl_surf3_val (HMGLgr,mrealval,HCDTa,const char *sch,const char *opt) - Функция С:
voidmgl_surf3_xyz_val (HMGLgr,mrealval,HCDTx,HCDTy,HCDTz,HCDTa,const char *sch,const char *opt) Рисует поверхность уровня для 3d массива, заданного параметрически a[i,j,k](x[i,j,k], y[i,j,k], z[i,j,k]) при a(x,y,z)=val. Если sch содержит ‘#’, то рисуется сетчатая поверхность. Если sch содержит ‘.’, то рисуется поверхность из точек. Замечу, что возможно некорректная отрисовка граней вследствие неопределённости построения сечения если поверхность пересекает ячейку данных 2 и более раз. См. также cloud, dens3, surf3c, surf3a, axial. См. раздел surf3 sample, для примеров кода и графика.
- Команда MGL: surf3 adat ['sch'='']
- Команда MGL: surf3 xdat ydat zdat adat ['sch'='']
- Метод класса
mglGraph:voidSurf3 (const mglDataA &a,const char *sch="",const char *opt="") - Метод класса
mglGraph:voidSurf3 (const mglDataA &x,const mglDataA &y,const mglDataA &z,const mglDataA &a,const char *sch="",const char *opt="") - Функция С:
voidmgl_surf3 (HMGLgr,HCDTa,const char *sch,const char *opt) - Функция С:
voidmgl_surf3_xyz (HMGLgr,HCDTx,HCDTy,HCDTz,HCDTa,const char *sch,const char *opt) Аналогично предыдущему для num поверхностей уровня равномерно распределённых в диапазоне изменения цвета. Величина num равна значению параметра
valueв опциях opt (по умолчанию 3).
- Команда MGL: cloud adat ['sch'='']
- Команда MGL: cloud xdat ydat zdat adat ['sch'='']
- Метод класса
mglGraph:voidCloud (const mglDataA &a,const char *sch="",const char *opt="") - Метод класса
mglGraph:voidCloud (const mglDataA &x,const mglDataA &y,const mglDataA &z,const mglDataA &a,const char *sch="",const char *opt="") - Функция С:
voidmgl_cloud (HMGLgr,HCDTa,const char *sch,const char *opt) - Функция С:
voidmgl_cloud_xyz (HMGLgr,HCDTx,HCDTy,HCDTz,HCDTa,const char *sch,const char *opt) Рисует облачный график для 3d массива, заданного параметрически a[i,j,k](x[i,j,k], y[i,j,k], z[i,j,k]). График состоит из кубиков с цветом и прозрачностью пропорциональной значениям a. Результат похож на облако – малые значения прозрачны, а большие нет. Число кубиков зависит от meshnum. Если sch содержит ‘.’, то будет построен график более низкого качества, но с заметно меньшим использованием памяти. Если sch содержит ‘i’, то прозрачность будет инвертирована, т.е. области с более высокими значениями будут более прозрачны, а с более низким – менее прозрачны. См. также surf3, meshnum. См. раздел cloud sample, для примеров кода и графика.
- Команда MGL: dens3 adat ['sch'=''
sval=-1] - Команда MGL: dens3 xdat ydat zdat adat ['sch'=''
sval=-1] - Метод класса
mglGraph:voidDens3 (const mglDataA &a,const char *sch="",mrealsVal=-1,const char *opt="") - Метод класса
mglGraph:voidDens3 (const mglDataA &x,const mglDataA &y,const mglDataA &z,const mglDataA &a,const char *sch="",mrealsVal=-1,const char *opt="") - Функция С:
voidmgl_dens3 (HMGLgr,HCDTa,const char *sch,mrealsVal,const char *opt) - Функция С:
voidmgl_dens3_xyz (HMGLgr,HCDTx,HCDTy,HCDTz,HCDTa,const char *sch,mrealsVal,const char *opt) Рисует график плотности для 3d массива, заданного параметрически a[i,j,k](x[i,j,k], y[i,j,k], z[i,j,k]). График рисуется на срезе sVal в направлении {‘x’, ‘y’, ‘z’}, указанном в строке sch (по умолчанию, в напралении ‘y’). Если sch содержит ‘#’, то на срезе рисуется сетка. См. также cont3, contf3, dens, grid3. См. раздел dens3 sample, для примеров кода и графика.
- Команда MGL: cont3 vdat adat ['sch'=''
sval=-1] - Команда MGL: cont3 vdat xdat ydat zdat adat ['sch'=''
sval=-1] - Метод класса
mglGraph:voidCont3 (const mglDataA &v,const mglDataA &a,const char *sch="",mrealsVal=-1,const char *opt="") - Метод класса
mglGraph:voidCont3 (const mglDataA &v,const mglDataA &x,const mglDataA &y,const mglDataA &z,const mglDataA &a,const char *sch="",mrealsVal=-1,const char *opt="") - Функция С:
voidmgl_cont3_val (HMGLgr,HCDTv,HCDTa,const char *sch,mrealsVal,const char *opt) - Функция С:
voidmgl_cont3_xyz_val (HMGLgr,HCDTv,HCDTx,HCDTy,HCDTz,HCDTa,const char *sch,mrealsVal,const char *opt) Рисует линии уровня для 3d массива, заданного параметрически a[i,j,k](x[i,j,k], y[i,j,k], z[i,j,k]). Линии рисуются для значений из массива v на срезе sVal в направлении {‘x’, ‘y’, ‘z’}, указанном в строке sch (по умолчанию, в напралении ‘y’). Если sch содержит ‘#’, то на срезе рисуется сетка. Если sch содержит ‘t’ или ‘T’, то значения v[k] будут выведены вдоль контуров над (или под) кривой. См. также dens3, contf3, cont, grid3. См. раздел cont3 sample, для примеров кода и графика.
- Команда MGL: cont3 adat ['sch'=''
sval=-1] - Команда MGL: cont3 xdat ydat zdat adat ['sch'=''
sval=-1] - Метод класса
mglGraph:voidCont3 (const mglDataA &a,const char *sch="",mrealsVal=-1,const char *opt="",const char *opt="") - Метод класса
mglGraph:voidCont3 (const mglDataA &x,const mglDataA &y,const mglDataA &z,const mglDataA &a,const char *sch="",mrealsVal=-1,const char *opt="") - Функция С:
voidmgl_cont3 (HMGLgr,HCDTa,const char *sch,mrealsVal,const char *opt) - Функция С:
voidmgl_cont3_xyz (HMGLgr,HCDTx,HCDTy,HCDTz,HCDTa,const char *sch,mrealsVal,const char *opt) Аналогично предыдущему для num линий уровня равномерно распределённых в диапазоне изменения цвета. Величина num равна значению параметра
valueв опциях opt (по умолчанию 7).
- Команда MGL: contf3 vdat adat ['sch'=''
sval=-1] - Команда MGL: contf3 vdat xdat ydat zdat adat ['sch'=''
sval=-1] - Метод класса
mglGraph:voidContf3 (const mglDataA &v,const mglDataA &a,const char *sch="",mrealsVal=-1,const char *opt="") - Метод класса
mglGraph:voidContf3 (const mglDataA &v,const mglDataA &x,const mglDataA &y,const mglDataA &z,const mglDataA &a,const char *sch="",mrealsVal=-1,const char *opt="") - Функция С:
voidmgl_contf3_val (HMGLgr,HCDTv,HCDTa,const char *sch,mrealsVal,const char *opt) - Функция С:
voidmgl_contf3_xyz_val (HMGLgr,HCDTv,HCDTx,HCDTy,HCDTz,HCDTa,const char *sch,mrealsVal,const char *opt) Рисует закрашенные линии (контуры) уровня для 3d массива, заданного параметрически a[i,j,k](x[i,j,k], y[i,j,k], z[i,j,k]). Линии рисуются для значений из массива v на срезе sVal в направлении {‘x’, ‘y’, ‘z’}, указанном в строке sch (по умолчанию, в напралении ‘y’). Если sch содержит ‘#’, то на срезе рисуется сетка. См. также dens3, cont3, contf, grid3. См. раздел contf3 sample, для примеров кода и графика.
- Команда MGL: contf3 adat ['sch'=''
sval=-1] - Команда MGL: contf3 xdat ydat zdat adat ['sch'=''
sval=-1] - Метод класса
mglGraph:voidContf3 (const mglDataA &a,const char *sch="",mrealsVal=-1,const char *opt="",const char *opt="") - Метод класса
mglGraph:voidContf3 (const mglDataA &x,const mglDataA &y,const mglDataA &z,const mglDataA &a,const char *sch="",mrealsVal=-1,const char *opt="") - Функция С:
voidmgl_contf3 (HMGLgr,HCDTa,const char *sch,mrealsVal,const char *opt) - Функция С:
voidmgl_contf3_xyz (HMGLgr,HCDTx,HCDTy,HCDTz,HCDTa,const char *sch,mrealsVal,const char *opt) Аналогично предыдущему для num закрашенных линий (контуров) уровня равномерно распределённых в диапазоне изменения цвета. Величина num равна значению параметра
valueв опциях opt (по умолчанию 7).
- Команда MGL: grid3 adat ['sch'=''
sval=-1] - Команда MGL: grid3 xdat ydat zdat adat ['sch'=''
sval=-1] - Метод класса
mglGraph:voidGrid3 (const mglDataA &a,const char *sch="",mrealsVal=-1,const char *opt="") - Метод класса
mglGraph:voidGrid3 (const mglDataA &x,const mglDataA &y,const mglDataA &z,const mglDataA &a,const char *sch="",mrealsVal=-1,const char *opt="") - Функция С:
voidmgl_grid3 (HMGLgr,HCDTa,const char *sch,mrealsVal,const char *opt) - Функция С:
voidmgl_grid3_xyz (HMGLgr,HCDTx,HCDTy,HCDTz,HCDTa,const char *sch,mrealsVal,const char *opt) Рисует сетку для 3d массива, заданного параметрически a[i,j,k](x[i,j,k], y[i,j,k], z[i,j,k]). График рисуется на срезе sVal в направлении {‘x’, ‘y’, ‘z’}, указанном в строке sch (по умолчанию, в напралении ‘y’). См. также cont3, contf3, dens3, grid2, meshnum.
- Команда MGL: beam tr g1 g2 adat
rval['sch'=''flag=0 num=3] - Метод класса
mglGraph:voidBeam (const mglDataA &tr,const mglDataA &g1,const mglDataA &g2,const mglDataA &a,mrealr,const char *stl="",intflag=0,intnum=3) - Метод класса
mglGraph:voidBeam (mrealval,const mglDataA &tr,const mglDataA &g1,const mglDataA &g2,const mglDataA &a,mrealr,const char *stl="",intflag=0) - Функция С:
voidmgl_beam (HMGLgr,HCDTtr,HCDTg1,HCDTg2,HCDTa,mrealr,const char *stl,intflag,intnum) - Функция С:
voidmgl_beam_val (HMGLgr,mrealval,HCDTtr,HCDTg1,HCDTg2,HCDTa,mrealr,const char *stl,intflag) Рисует поверхность уровня для 3d массива a при постоянном значении a=val. Это специальный тип графика для a заданного в сопровождающей системе координат вдоль кривой tr с ортами g1, g2 и с поперечным размером r. Переменная flag – битовый флаг: ‘0x1’ - рисовать в сопровождающих (не лабораторных) координатах; ‘0x2’ - рисовать проекцию на плоскость \rho-z; ‘0x4’ - рисовать нормированное в каждом сечении поле. Размеры массивов по 1-му индексу tr, g1, g2 должны быть nx>2. Размеры массивов по 2-му индексу tr, g1, g2 и размер по 3-му индексу массива a должны быть одинаковы. См. также surf3.
Next: Vector fields, Previous: 3D plotting, Up: MathGL core [Contents][Index]
4.14 Парные графики
Эти функции строят графики для двух связанных массивов. Есть несколько основных типов 3D графиков: поверхность и поверхность уровня с окраской по второму массиву (SurfC, Surf3C), поверхность и поверхность уровня с прозрачностью по второму массиву (SurfA, Surf3A), плитки переменного размера (TileS), диаграмма точечного отображения (Map), STFA диаграмма (STFA). По умолчанию (если отсутствуют) значения x, y (и z для Surf3C, Surf3A) равно распределены в диапазоне осей координат. Младшие размерности массивов x, y, z, c должны быть одинаковы x.nx=a.nx && y.nx=a.ny && z.nz=a.nz или x.nx=y.nx=z.nx=a.nx && x.ny=y.ny=z.ny=a.ny && x.nz=y.nz=z.nz=a.nz. Массивы x, y (и z для Surf3C, Surf3A) могут быть векторами (не матрицами как c). Строка sch задает цветовую схему (см. Color scheme). Строка opt задает опции графика (см. Command options).
- Команда MGL: surfc zdat cdat ['sch'='']
- Команда MGL: surfc xdat ydat zdat cdat ['sch'='']
- Метод класса
mglGraph:voidSurfC (const mglDataA &z,const mglDataA &c,const char *sch="",const char *opt="") - Метод класса
mglGraph:voidSurfC (const mglDataA &x,const mglDataA &y,const mglDataA &z,const mglDataA &c,const char *sch="",const char *opt="") - Функция С:
voidmgl_surfc (HMGLgr,HCDTz,HCDTc,const char *sch,const char *opt) - Функция С:
voidmgl_surfc_xy (HMGLgr,HCDTx,HCDTy,HCDTz,HCDTc,const char *sch,const char *opt) Рисует параметрически заданную поверхность {x[i,j], y[i,j], z[i,j]} с цветом, заданным массивом c[i,j]. Если sch содержит ‘#’, то на поверхности рисуется сетка. Если sch содержит ‘.’, то рисуется поверхность из точек. Размерность массивов z и c должна быть одинакова. График строится для каждого z среза данных. См. также surf, surfa, beltc, surf3c. См. раздел surfc sample, для примеров кода и графика.
- Команда MGL: beltc zdat cdat ['sch'='']
- Команда MGL: beltc xdat ydat zdat cdat ['sch'='']
- Метод класса
mglGraph:voidBeltC (const mglDataA &z,const char *sch="",const char *opt="") - Метод класса
mglGraph:voidBeltC (const mglDataA &x,const mglDataA &y,const mglDataA &z,const char *sch="",const char *opt="") - Функция С:
voidmgl_beltc (HMGLgr,HCDTz,const char *sch,const char *opt) - Функция С:
voidmgl_beltc_xy (HMGLgr,HCDTx,HCDTy,HCDTz,const char *sch,const char *opt) Рисует ленточки для параметрически заданной поверхности {x[i,j], y[i,j], z[i,j]} с цветом, заданным массивом c[i,j]. График может использоваться как 3d обобщение графика plot. Если sch содержит ‘x’, то ленточки рисуются вдоль оси x, иначе (по умолчанию) вдоль оси y. См. также belt, surfc, meshnum.
- Команда MGL: surf3c adat cdat
val['sch'=''] - Команда MGL: surf3c xdat ydat zdat adat cdat
val['sch'=''] - Метод класса
mglGraph:voidSurf3C (mrealval,const mglDataA &a,const mglDataA &c,const char *sch="",const char *opt="") - Метод класса
mglGraph:voidSurf3C (mrealval,const mglDataA &x,const mglDataA &y,const mglDataA &z,const mglDataA &a,const mglDataA &c,const char *sch="",const char *opt="") - Функция С:
voidmgl_surf3c_val (HMGLgr,mrealval,HCDTa,HCDTc,const char *sch,const char *opt) - Функция С:
voidmgl_surf3c_xyz_val (HMGLgr,mrealval,HCDTx,HCDTy,HCDTz,HCDTa,HCDTc,const char *sch,const char *opt) Рисует поверхность уровня для 3d массива, заданного параметрически a[i,j,k](x[i,j,k], y[i,j,k], z[i,j,k]) при a(x,y,z)=val. Аналогично surf3, но цвет задается массивом c. Если sch содержит ‘#’, то рисуется сетчатая поверхность. Если sch содержит ‘.’, то рисуется поверхность из точек. См. также surf3, surfc, surf3a. См. раздел surf3c sample, для примеров кода и графика.
- Команда MGL: surf3c adat cdat ['sch'='']
- Команда MGL: surf3c xdat ydat zdat adat cdat ['sch'='']
- Метод класса
mglGraph:voidSurf3C (const mglDataA &a,const mglDataA &c,const char *sch="",const char *opt="") - Метод класса
mglGraph:voidSurf3C (const mglDataA &x,const mglDataA &y,const mglDataA &z,const mglDataA &a,const mglDataA &c,const char *sch="",const char *opt="") - Функция С:
voidmgl_surf3c (HMGLgr,HCDTa,HCDTc,const char *sch,const char *opt) - Функция С:
voidmgl_surf3c_xyz (HMGLgr,HCDTx,HCDTy,HCDTz,HCDTa,HCDTc,const char *sch,const char *opt) Аналогично предыдущему для num поверхностей уровня равномерно распределённых в диапазоне изменения цвета. Величина num равна значению параметра
valueв опциях opt (по умолчанию 3).
- Команда MGL: surfa zdat cdat ['sch'='']
- Команда MGL: surfa xdat ydat zdat cdat ['sch'='']
- Метод класса
mglGraph:voidSurfA (const mglDataA &z,const mglDataA &c,const char *sch="",const char *opt="") - Метод класса
mglGraph:voidSurfA (const mglDataA &x,const mglDataA &y,const mglDataA &z,const mglDataA &c,const char *sch="",const char *opt="") - Функция С:
voidmgl_surfa (HMGLgr,HCDTz,HCDTc,const char *sch,const char *opt) - Функция С:
voidmgl_surfa_xy (HMGLgr,HCDTx,HCDTy,HCDTz,HCDTc,const char *sch,const char *opt) Рисует параметрически заданную поверхность {x[i,j], y[i,j], z[i,j]} с прозрачностью, заданной массивом c[i,j]. Если sch содержит ‘#’, то на поверхности рисуется сетка. Если sch содержит ‘.’, то рисуется поверхность из точек. Размерность массивов z и c должна быть одинакова. График строится для каждого z среза данных. См. также surf, surfc, surf3a. См. раздел surfa sample, для примеров кода и графика.
- Команда MGL: surf3a adat cdat
val['sch'=''] - Команда MGL: surf3a xdat ydat zdat adat cdat
val['sch'=''] - Метод класса
mglGraph:voidSurf3A (mrealval,const mglDataA &a,const mglDataA &c,const char *sch="",const char *opt="") - Метод класса
mglGraph:voidSurf3A (mrealval,const mglDataA &x,const mglDataA &y,const mglDataA &z,const mglDataA &a,const mglDataA &c,const char *sch="",const char *opt="") - Функция С:
voidmgl_surf3a_val (HMGLgr,mrealval,HCDTa,HCDTc,const char *sch,const char *opt) - Функция С:
voidmgl_surf3a_xyz_val (HMGLgr,mrealval,HCDTx,HCDTy,HCDTz,HCDTa,HCDTc,const char *sch,const char *opt) Рисует поверхность уровня для 3d массива, заданного параметрически a[i,j,k](x[i,j,k], y[i,j,k], z[i,j,k]) при a(x,y,z)=val. Аналогично surf3, но прозрачность задается массивом c. Если sch содержит ‘#’, то рисуется сетчатая поверхность. Если sch содержит ‘.’, то рисуется поверхность из точек. См. также surf3, surfc, surf3a. См. раздел surf3a sample, для примеров кода и графика.
- Команда MGL: surf3a adat cdat ['sch'='']
- Команда MGL: surf3a xdat ydat zdat adat cdat ['sch'='']
- Метод класса
mglGraph:voidSurf3A (const mglDataA &a,const mglDataA &c,const char *sch="",const char *opt="") - Метод класса
mglGraph:voidSurf3A (const mglDataA &x,const mglDataA &y,const mglDataA &z,const mglDataA &a,const mglDataA &c,const char *sch="",const char *opt="") - Функция С:
voidmgl_surf3a (HMGLgr,HCDTa,HCDTc,const char *sch,const char *opt) - Функция С:
voidmgl_surf3a_xyz (HMGLgr,HCDTx,HCDTy,HCDTz,HCDTa,HCDTc,const char *sch,const char *opt) Аналогично предыдущему для num поверхностей уровня равномерно распределённых в диапазоне изменения цвета. При этом массив c может быть вектором со значениями прозрачности и num=c.nx. В противном случае величина num равна значению параметра
valueв опциях opt (по умолчанию 3).
- Команда MGL: surfca zdat cdat adat ['sch'='']
- Команда MGL: surfca xdat ydat zdat cdat adat ['sch'='']
- Метод класса
mglGraph:voidSurfCA (const mglDataA &z,const mglDataA &c,const mglDataA &a,const char *sch="",const char *opt="") - Метод класса
mglGraph:voidSurfCA (const mglDataA &x,const mglDataA &y,const mglDataA &z,const mglDataA &c,const mglDataA &a,const char *sch="",const char *opt="") - Функция С:
voidmgl_surfca (HMGLgr,HCDTz,HCDTc,HCDTa,const char *sch,const char *opt) - Функция С:
voidmgl_surfca_xy (HMGLgr,HCDTx,HCDTy,HCDTz,HCDTc,HCDTa,const char *sch,const char *opt) Рисует параметрически заданную поверхность {x[i,j], y[i,j], z[i,j]} с цветом и прозрачностью, заданными массивами c[i,j] и a[i,j] соответственно. Если sch содержит ‘#’, то на поверхности рисуется сетка. Если sch содержит ‘.’, то рисуется поверхность из точек. Размерность массивов z и c должна быть одинакова. График строится для каждого z среза данных. См. также surf, surfc, surfa, surf3ca. См. раздел surfca sample, для примеров кода и графика.
- Команда MGL: surf3ca adat cdat bdat
val['sch'=''] - Команда MGL: surf3ca xdat ydat zdat adat cdat bdat
val['sch'=''] - Метод класса
mglGraph:voidSurf3CA (mrealval,const mglDataA &a,const mglDataA &c,const mglDataA &b,const char *sch="",const char *opt="") - Метод класса
mglGraph:voidSurf3CA (mrealval,const mglDataA &x,const mglDataA &y,const mglDataA &z,const mglDataA &a,const mglDataA &c,const mglDataA &b,const char *sch="",const char *opt="") - Функция С:
voidmgl_surf3ca_val (HMGLgr,mrealval,HCDTa,HCDTc,HCDTb,const char *sch,const char *opt) - Функция С:
voidmgl_surf3ca_xyz_val (HMGLgr,mrealval,HCDTx,HCDTy,HCDTz,HCDTa,HCDTc,HCDTb,const char *sch,const char *opt) Рисует поверхность уровня для 3d массива, заданного параметрически a[i,j,k](x[i,j,k], y[i,j,k], z[i,j,k]) при a(x,y,z)=val. Аналогично surf3, но цвет и прозрачность задается массивами c и b соответственно. Если sch содержит ‘#’, то рисуется сетчатая поверхность. Если sch содержит ‘.’, то рисуется поверхность из точек. См. также surf3, surfc, surf3a. См. раздел surf3a sample, для примеров кода и графика.
- Команда MGL: surf3ca adat cdat ['sch'='']
- Команда MGL: surf3ca xdat ydat zdat adat cdat ['sch'='']
- Метод класса
mglGraph:voidSurf3CA (const mglDataA &a,const mglDataA &c,const mglDataA &b,const char *sch="",const char *opt="") - Метод класса
mglGraph:voidSurf3CA (const mglDataA &x,const mglDataA &y,const mglDataA &z,const mglDataA &a,const mglDataA &c,const mglDataA &b,const char *sch="",const char *opt="") - Функция С:
voidmgl_surf3ca (HMGLgr,HCDTa,HCDTc,HCDTb,const char *sch,const char *opt) - Функция С:
voidmgl_surf3ca_xyz (HMGLgr,HCDTx,HCDTy,HCDTz,HCDTa,HCDTc,HCDTb,const char *sch,const char *opt) Аналогично предыдущему для num поверхностей уровня равномерно распределённых в диапазоне изменения цвета. Здесь величина num равна значению параметра
valueв опциях opt (по умолчанию 3).
- Команда MGL: tiles zdat rdat ['sch'='']
- Команда MGL: tiles xdat ydat zdat rdat ['sch'='']
- Команда MGL: tiles xdat ydat zdat rdat cdat ['sch'='']
- Метод класса
mglGraph:voidTileS (const mglDataA &z,const mglDataA &c,const char *sch="",const char *opt="") - Метод класса
mglGraph:voidTileS (const mglDataA &x,const mglDataA &y,const mglDataA &z,const mglDataA &r,const char *sch="",const char *opt="") - Метод класса
mglGraph:voidTileS (const mglDataA &x,const mglDataA &y,const mglDataA &z,const mglDataA &r,const mglDataA &c,const char *sch="",const char *opt="") - Функция С:
voidmgl_tiles (HMGLgr,HCDTz,HCDTc,const char *sch,const char *opt) - Функция С:
voidmgl_tiles_xy (HMGLgr,HCDTx,HCDTy,HCDTz,HCDTr,const char *sch,const char *opt) - Функция С:
voidmgl_tiles_xyc (HMGLgr,HCDTx,HCDTy,HCDTz,HCDTr,HCDTc,const char *sch,const char *opt) Рисует плитки для параметрически заданной поверхности {x[i,j], y[i,j], z[i,j]} с цветом, заданным массивом c[i,j]. Аналогично Tile(), но размер плиток задается массивов r. Если строка sch содержит стиль ‘x’ или ‘y’, то плитки будут ориентированы перпендикулярно x- или y-оси. Это создает эффект "прозрачности" при экспорте в файлы EPS. График строится для каждого z среза данных. См. также surfa, tile. См. раздел tiles sample, для примеров кода и графика.
- Команда MGL: map udat vdat ['sch'='']
- Команда MGL: map xdat ydat udat vdat ['sch'='']
- Метод класса
mglGraph:voidMap (const mglDataA &ax,const mglDataA &ay,const char *sch="",const char *opt="") - Метод класса
mglGraph:voidMap (const mglDataA &x,const mglDataA &y,const mglDataA &ax,const mglDataA &ay,const char *sch="",const char *opt="") - Функция С:
voidmgl_map (HMGLgr,HCDTax,HCDTay,const char *sch,const char *opt) - Функция С:
voidmgl_map_xy (HMGLgr,HCDTx,HCDTy,HCDTax,HCDTay,const char *sch,const char *opt) Рисует точечное отображение для матриц {ax, ay } параметрически зависящих от координат x, y. Исходное положение ячейки задает ее цвет. Высота пропорциональна якобиану J(ax,ay). График является аналогом диаграммы Арнольда ??? Если sch содержит ‘.’, то цветные точки рисуются в узлах матриц (полезно для "запутанного" отображения), иначе рисуются грани. См. раздел Mapping visualization, для примеров кода и графика.
- Команда MGL: stfa re im
dn['sch'=''] - Команда MGL: stfa xdat ydat re im
dn['sch'=''] - Метод класса
mglGraph:voidSTFA (const mglDataA &re,const mglDataA &im,intdn,const char *sch="",const char *opt="") - Метод класса
mglGraph:voidSTFA (const mglDataA &x,const mglDataA &y,const mglDataA &re,const mglDataA &im,intdn,const char *sch="",const char *opt="") - Функция С:
voidmgl_stfa (HMGLgr,HCDTre,HCDTim,intdn,const char *sch,const char *opt) - Функция С:
voidmgl_stfa_xy (HMGLgr,HCDTx,HCDTy,HCDTre,HCDTim,intdn,const char *sch,const char *opt) Рисует спектрограмму комплексного массива re+i*im для Фурье размером dn точек в плоскости z равно минимальному значению оси z. Параметр dn – любое чётное число. Например в 1D случае, результатом будет график плотности от массива res[i,j]=|\sum_d^dn exp(I*j*d)*(re[i*dn+d]+I*im[i*dn+d])|/dn размером {int(nx/dn), dn, ny}. Массивы re, im параметрически зависят от координат x, y. Все размеры массивов re и im должны быть одинаковы. Младшие размерности массивов x, y, re должны быть одинаковы. Массивы x и y могут быть векторами (не матрицами как re). См. раздел stfa sample, для примеров кода и графика.
Next: Other plotting, Previous: Dual plotting, Up: MathGL core [Contents][Index]
4.15 Векторные поля
Эти функции рисуют графики для 2D и 3D векторных полей. Есть несколько типов графиков: просто векторное поле (Vect), вектора вдоль траектории (Traj), векторное поле каплями (Dew), нити тока (Flow, FlowP), трубки тока (Pipe). По умолчанию (если отсутствуют) значения x, y и z равно распределены в диапазоне осей координат. Младшие размерности массивов x, y, z и ax должны быть одинаковы. Размеры массивов ax, ay и az должны быть одинаковы. Массивы x, y и z могут быть векторами (не матрицами как ax). Строка sch задает цветовую схему (см. Color scheme). Строка opt задает опции графика (см. Command options).
- Команда MGL: traj xdat ydat udat vdat ['sch'='']
- Команда MGL: traj xdat ydat zdat udat vdat wdat ['sch'='']
- Метод класса
mglGraph:voidTraj (const mglDataA &x,const mglDataA &y,const mglDataA &ax,const mglDataA &ay,const char *sch="",const char *opt="") - Метод класса
mglGraph:voidTraj (const mglDataA &x,const mglDataA &y,const mglDataA &z,const mglDataA &ax,const mglDataA &ay,const mglDataA &az,const char *sch="",const char *opt="") - Функция С:
voidmgl_traj_xyz (HMGLgr,HCDTx,HCDTy,HCDTz,HCDTax,HCDTay,HCDTaz,const char *sch,const char *opt) - Функция С:
voidmgl_traj_xy (HMGLgr,HCDTx,HCDTy,HCDTax,HCDTay,const char *sch,const char *opt) Рисует вектора {ax, ay, az} вдоль кривой {x, y, z}. Длина векторов пропорциональна \sqrt{ax^2+ay^2+az^2}. Строка pen задает цвет (см. Line styles). По умолчанию (
pen="") используется текущий цвет из палитры (см. Palette and colors). Опцияvalueзадает фактор длины векторов (если не нуль) или выбирать длину пропорционально расстоянию между точками кривой (еслиvalue=0). Размер по 1-му индексу должен быть 2 или больше. График рисуется для каждой строки если один из массивов матрица. См. также vect. См. раздел traj sample, для примеров кода и графика.
- Команда MGL: vect udat vdat ['sch'='']
- Команда MGL: vect xdat ydat udat vdat ['sch'='']
- Метод класса
mglGraph:voidVect (const mglDataA &ax,const mglDataA &ay,const char *sch="",const char *opt="") - Метод класса
mglGraph:voidVect (const mglDataA &x,const mglDataA &y,const mglDataA &ax,const mglDataA &ay,const char *sch="",const char *opt="") - Функция С:
voidmgl_vect_2d (HMGLgr,HCDTax,HCDTay,const char *sch,const char *opt) - Функция С:
voidmgl_vect_xy (HMGLgr,HCDTx,HCDTy,HCDTax,HCDTay,const char *sch,const char *opt) Рисует векторное поле {ax, ay} параметрически зависящее от координат x, y на плоскости при z равном минимальному значению оси z. Длина и цвет векторов пропорциональна \sqrt{ax^2+ay^2}. Число рисуемых векторов зависит от meshnum. Вид стрелок/штрихов может быть изменён символами:
- ‘f’ для стрелок одинаковой длины,
- ‘>’, ‘<’ для стрелок начинающихся или заканчивающихся в ячейке сетки (по умолчанию центрированы),
- ‘.’ для рисования штрихов с точкой в начале вместо стрелок,
- ‘=’ для использования градиента цвета вдоль стрелок.
См. также flow, dew. См. раздел vect sample, для примеров кода и графика.
- Команда MGL: vect udat vdat wdat ['sch'='']
- Команда MGL: vect xdat ydat zdat udat vdat wdat ['sch'='']
- Метод класса
mglGraph:voidVect (const mglDataA &ax,const mglDataA &ay,const mglDataA &az,const char *sch="",const char *opt="") - Метод класса
mglGraph:voidVect (const mglDataA &x,const mglDataA &y,const mglDataA &z,const mglDataA &ax,const mglDataA &ay,const mglDataA &az,const char *sch="",const char *opt="") - Функция С:
voidmgl_vect_3d (HMGLgr,HCDTax,HCDTay,HCDTaz,const char *sch,const char *opt) - Функция С:
voidmgl_vect_xyz (HMGLgr,HCDTx,HCDTy,HCDTz,HCDTax,HCDTay,HCDTaz,const char *sch,const char *opt) Это 3d версия графика. Здесь массивы ax, ay, az должны трёхмерными тензорами и длина вектора пропорциональна \sqrt{ax^2+ay^2+az^2}.
- Команда MGL: vect3 udat vdat wdat ['sch'='' sval]
- Команда MGL: vect3 xdat ydat zdat udat vdat wdat ['sch'='' sval]
- Метод класса
mglGraph:voidVect3 (const mglDataA &ax,const mglDataA &ay,const mglDataA &az,const char *sch="",mrealsVal=-1,const char *opt="") - Метод класса
mglGraph:voidVect3 (const mglDataA &x,const mglDataA &y,const mglDataA &z,const mglDataA &ax,const mglDataA &ay,const mglDataA &az,const char *sch="",mrealsVal=-1,const char *opt="") - Функция С:
voidmgl_vect3 (HMGLgr,HCDTax,HCDTay,HCDTaz,const char *sch,mrealsVal,const char *opt) - Функция С:
voidmgl_vect3_xyz (HMGLgr,HCDTx,HCDTy,HCDTz,HCDTax,HCDTay,HCDTaz,const char *sch,mrealsVal,const char *opt) Рисует 3D векторное поле {ax, ay, az} параметрически зависящее от координат x, y, z. График рисуется на срезе sVal в направлении {‘x’, ‘y’, ‘z’}, указанном в строке sch (по умолчанию, в напралении ‘y’). Длина и цвет векторов пропорциональна \sqrt{ax^2+ay^2+az^2}. Число рисуемых векторов зависит от meshnum. Вид стрелок/штрихов может быть изменён символами:
- ‘f’ для стрелок одинаковой длины,
- ‘>’, ‘<’ для стрелок начинающихся или заканчивающихся в ячейке сетки (по умолчанию центрированы),
- ‘.’ для рисования штрихов с точкой в начале вместо стрелок,
- ‘=’ для использования градиента цвета вдоль стрелок.
См. также vect, flow, dew. См. раздел vect sample, для примеров кода и графика.
- Команда MGL: dew udat vdat ['sch'='']
- Команда MGL: dew xdat ydat udat vdat ['sch'='']
- Метод класса
mglGraph:voidDew (const mglDataA &ax,const mglDataA &ay,const char *sch="",const char *opt="") - Метод класса
mglGraph:voidDew (const mglDataA &x,const mglDataA &y,const mglDataA &ax,const mglDataA &ay,const char *sch="",const char *opt="") - Функция С:
voidmgl_dew (HMGLgr,HCDTax,HCDTay,const char *sch,const char *opt) - Функция С:
voidmgl_dew_xy (HMGLgr,HCDTx,HCDTy,HCDTax,HCDTay,const char *sch,const char *opt) Рисует капли для векторного поля {ax, ay}, параметрически зависящего от координат x, y при z равном минимальному значению оси z. Замечу, что график требует много памяти и процессорного времени для своего создания! Цвет капель пропорционален \sqrt{ax^2+ay^2}. Число капель определяется meshnum. См. также vect. См. раздел dew sample, для примеров кода и графика.
- Команда MGL: flow udat vdat ['sch'='']
- Команда MGL: flow xdat ydat udat vdat ['sch'='']
- Метод класса
mglGraph:voidFlow (const mglDataA &ax,const mglDataA &ay,const char *sch="",const char *opt="") - Метод класса
mglGraph:voidFlow (const mglDataA &x,const mglDataA &y,const mglDataA &ax,const mglDataA &ay,const char *sch="",const char *opt="") - Функция С:
voidmgl_flow_2d (HMGLgr,HCDTax,HCDTay,const char *sch,const char *opt) - Функция С:
voidmgl_flow_xy (HMGLgr,HCDTx,HCDTy,HCDTax,HCDTay,const char *sch,const char *opt) Рисует нити тока для векторного поля {ax, ay}, параметрически зависящего от координат x, y на плоскости при z равном минимальному значению оси z. Число нитей пропорционально значению опции
value(по умолчанию 5). Цвет нитей пропорционален \sqrt{ax^2+ay^2}. Строка sch может содержать- цветовую схему – тёплые цвета соответствуют нормальному току (типа стока), холодные цвета соответствуют обратному току (типа источника);
- ‘#’ для использования нитей, начинающихся только на границе;
- ‘.’ для рисования сепаратрис (нитей из/в стационарных точек).
- ‘*’ для использования нитей, начинающихся с двумерной сетки внутри данных;
- ‘v’ для рисования стрелок на нитях;
- ‘x’, ‘z’ для рисования лент нормалей, начинающихся в плоскостях x-y и y-z соответственно.
См. также pipe, vect, tape, flow3, barwidth. См. раздел flow sample, для примеров кода и графика.
- Команда MGL: flow udat vdat wdat ['sch'='']
- Команда MGL: flow xdat ydat zdat udat vdat wdat ['sch'='']
- Метод класса
mglGraph:voidFlow (const mglDataA &ax,const mglDataA &ay,const mglDataA &az,const char *sch="",const char *opt="") - Метод класса
mglGraph:voidFlow (const mglDataA &x,const mglDataA &y,const mglDataA &z,const mglDataA &ax,const mglDataA &ay,const mglDataA &az,const char *sch="",const char *opt="") - Функция С:
voidmgl_flow_3d (HMGLgr,HCDTax,HCDTay,HCDTaz,const char *sch,const char *opt) - Функция С:
voidmgl_flow_xyz (HMGLgr,HCDTx,HCDTy,HCDTz,HCDTax,HCDTay,HCDTaz,const char *sch,const char *opt) Это 3d версия графика. Здесь массивы должны трёхмерными тензорами и цвет пропорционален \sqrt{ax^2+ay^2+az^2}.
- Команда MGL: flow
x0 y0udat vdat ['sch'=''] - Команда MGL: flow
x0 y0xdat ydat udat vdat ['sch'=''] - Метод класса
mglGraph:voidFlowP (mglPointp0,const mglDataA &ax,const mglDataA &ay,const char *sch="",const char *opt="") - Метод класса
mglGraph:voidFlowP (mglPointp0,const mglDataA &x,const mglDataA &y,const mglDataA &ax,const mglDataA &ay,const char *sch="",const char *opt="") - Функция С:
voidmgl_flowp_2d (HMGLgr,mrealx0,mrealy0,mrealz0,HCDTax,HCDTay,const char *sch,const char *opt) - Функция С:
voidmgl_flowp_xy (HMGLgr,mrealx0,mrealy0,mrealz0,HCDTx,HCDTy,HCDTax,HCDTay,const char *sch,const char *opt) Аналогично flow, но рисует одну нить из точки p0={x0,y0,z0}. Строка sch также может содержать: ‘>’ или ‘<’ для рисования линии тока только вперед или только назад от заданной точки (по умолчанию, рисует в обе стороны).
- Команда MGL: flow
x0 y0 z0udat vdat wdat ['sch'=''] - Команда MGL: flow
x0 y0 z0xdat ydat zdat udat vdat wdat ['sch'=''] - Метод класса
mglGraph:voidFlowP (mglPointp0,const mglDataA &ax,const mglDataA &ay,const mglDataA &az,const char *sch="",const char *opt="") - Метод класса
mglGraph:voidFlowP (mglPointp0,const mglDataA &x,const mglDataA &y,const mglDataA &z,const mglDataA &ax,const mglDataA &ay,const mglDataA &az,const char *sch="",const char *opt="") - Функция С:
voidmgl_flowp_3d (HMGLgr,mrealx0,mrealy0,mrealz0,HCDTax,HCDTay,HCDTaz,const char *sch,const char *opt) - Функция С:
voidmgl_flowp_xyz (HMGLgr,mrealx0,mrealy0,mrealz0,HCDTx,HCDTy,HCDTz,HCDTax,HCDTay,HCDTaz,const char *sch,const char *opt) Это 3d версия графика.
- MGL command: flow3 udat vdat wdat ['sch'='']
- MGL command: flow3 xdat ydat zdat udat vdat ['sch'='']
- Method on
mglGraph:voidFlow3 (const mglDataA &ax,const mglDataA &ay,const mglDataA &az,const char *sch="",doublesVal=-1,const char *opt="") - Method on
mglGraph:voidFlow3 (const mglDataA &x,const mglDataA &y,const mglDataA &z,const mglDataA &ax,const mglDataA &ay,const mglDataA &az,const char *sch="",doublesVal=-1,const char *opt="") - C function:
voidmgl_flow3 (HMGLgr,HCDTax,HCDTay,HCDTaz,const char *sch,doublesVal,const char *opt) - C function:
voidmgl_flow3_xyz (HMGLgr,HCDTx,HCDTy,HCDTz,HCDTax,HCDTay,HCDTaz,const char *sch,doublesVal,const char *opt) The function draws flow threads for the 3D vector field {ax, ay, az} parametrically depending on coordinates x, y, z. Flow threads starts from given plane. Option
valueset the approximate number of threads (default is 5). String sch may contain:- color scheme – up-half (warm) corresponds to normal flow (like attractor), bottom-half (cold) corresponds to inverse flow (like source);
- ‘x’, ‘z’ for normal of starting plane (default is y-direction);
- ‘v’ for drawing arrows on the threads;
- ‘t’ for drawing tapes of normals in x-y and y-z planes.
See also flow, pipe, vect. См. раздел flow3 sample, для примеров кода и графика.
- Команда MGL: grad pdat ['sch'='']
- Команда MGL: grad xdat ydat pdat ['sch'='']
- Команда MGL: grad xdat ydat zdat pdat ['sch'='']
- Метод класса
mglGraph:voidGrad (const mglDataA &phi,const char *sch="",const char *opt="") - Метод класса
mglGraph:voidGrad (const mglDataA &x,const mglDataA &y,const mglDataA &phi,const char *sch="",const char *opt="") - Метод класса
mglGraph:voidGrad (const mglDataA &x,const mglDataA &y,const mglDataA &z,const mglDataA &phi,const char *sch="",const char *opt="") - Функция С:
voidmgl_grad (HMGLgr,HCDTphi,const char *sch,const char *opt) - Функция С:
voidmgl_grad_xy (HMGLgr,HCDTx,HCDTy,HCDTphi,const char *sch,const char *opt) - Функция С:
voidmgl_grad_xyz (HMGLgr,HCDTx,HCDTy,HCDTz,HCDTphi,const char *sch,const char *opt) Рисует линии градиента скалярного поля phi[i,j] (или phi[i,j,k] в 3d случае) заданного параметрически {x[i,j,k], y[i,j,k], z[i,j,k]}. Число линий пропорционально значению опции
value(по умолчанию 5). См. также dens, cont, flow.
- Команда MGL: pipe udat vdat ['sch'=''
r0=0.05] - Команда MGL: pipe xdat ydat udat vdat ['sch'=''
r0=0.05] - Метод класса
mglGraph:voidPipe (const mglDataA &ax,const mglDataA &ay,const char *sch="",mrealr0=0.05,const char *opt="") - Метод класса
mglGraph:voidPipe (const mglDataA &x,const mglDataA &y,const mglDataA &ax,const mglDataA &ay,const char *sch="",mrealr0=0.05,const char *opt="") - Функция С:
voidmgl_pipe_2d (HMGLgr,HCDTax,HCDTay,const char *sch,mrealr0,const char *opt) - Функция С:
voidmgl_pipe_xy (HMGLgr,HCDTx,HCDTy,HCDTax,HCDTay,const char *sch,mrealr0,const char *opt) Рисует трубки тока для векторного поля {ax, ay}, параметрически зависящего от координат x, y на плоскости при z равном минимальному значению оси z. Число трубок пропорционально значению опции
value. Цвет и радиус трубок пропорционален \sqrt{ax^2+ay^2}. Тёплые цвета соответствуют нормальному току (типа стока). Холодные цвета соответствуют обратному току (типа источника). Параметр r0 задает радиус трубок. При r0<0 радиус трубок обратно пропорционален их амплитуде. См. также flow, vect. См. раздел pipe sample, для примеров кода и графика.
- Команда MGL: pipe udat vdat wdat ['sch'=''
r0=0.05] - Команда MGL: pipe xdat ydat zdat udat vdat wdat ['sch'=''
r0=0.05] - Метод класса
mglGraph:voidPipe (const mglDataA &ax,const mglDataA &ay,const mglDataA &az,const char *sch="",mrealr0=0.05,const char *opt="") - Метод класса
mglGraph:voidPipe (const mglDataA &x,const mglDataA &y,const mglDataA &z,const mglDataA &ax,const mglDataA &ay,const mglDataA &az,const char *sch="",mrealr0=0.05,const char *opt="") - Функция С:
voidmgl_pipe_3d (HMGLgr,HCDTax,HCDTay,HCDTaz,const char *sch,mrealr0,const char *opt) - Функция С:
voidmgl_pipe_xyz (HMGLgr,HCDTx,HCDTy,HCDTz,HCDTax,HCDTay,HCDTaz,const char *sch,mrealr0,const char *opt) Это 3d версия графика. Здесь массивы ax, ay, az должны трёхмерными тензорами и цвет пропорционален \sqrt{ax^2+ay^2+az^2}.
Next: Nonlinear fitting, Previous: Vector fields, Up: MathGL core [Contents][Index]
4.16 Прочие графики
Это функции, не относящиеся к какой-то специальной категории. Сюда входят функции построения графиков по текстовым формулам (FPlot и FSurf), рисования поверхностей из треугольников и четырёхугольников (TriPlot, TriCont, QuadPlot), произвольных точек в пространстве (Dots) и реконструкции по ним поверхности (Crust), графики плотности и линии уровня на плоскостях, перпендикулярных осям x, y или z (Dens[XYZ], Cont[XYZ], ContF[XYZ]). Каждый тип графика имеет похожий интерфейс. Есть версия для рисования одного массива с автоматическими координатами и версия для параметрически заданного массива. Параметры цветовой схемы задаются строкой. See Color scheme.
- Команда MGL: densx dat ['sch'=''
sval=nan] - Команда MGL: densy dat ['sch'=''
sval=nan] - Команда MGL: densz dat ['sch'=''
sval=nan] - Метод класса
mglGraph:voidDensX (const mglDataA &a,const char *stl="",mrealsVal=NAN,const char *opt="") - Метод класса
mglGraph:voidDensY (const mglDataA &a,const char *stl="",mrealsVal=NAN,const char *opt="") - Метод класса
mglGraph:voidDensZ (const mglDataA &a,const char *stl="",mrealsVal=NAN,const char *opt="") - Функция С:
voidmgl_dens_x (HMGLgr,HCDTa,const char *stl,mrealsVal,const char *opt) - Функция С:
voidmgl_dens_y (HMGLgr,HCDTa,const char *stl,mrealsVal,const char *opt) - Функция С:
voidmgl_dens_z (HMGLgr,HCDTa,const char *stl,mrealsVal,const char *opt) Эти функции рисуют график плотности на x, y или z плоскостях. Если a – 3d массив, то выполняется интерполяция к заданному срезу sVal. Функции полезны для создания проекций 3D массивов на оси координат. См. также ContXYZ, ContFXYZ, dens, Data manipulation. См. раздел dens_xyz sample, для примеров кода и графика.
- Команда MGL: contx dat ['sch'=''
sval=nan] - Команда MGL: conty dat ['sch'=''
sval=nan] - Команда MGL: contz dat ['sch'=''
sval=nan] - Метод класса
mglGraph:voidContX (const mglDataA &a,const char *stl="",mrealsVal=NAN,const char *opt="") - Метод класса
mglGraph:voidContY (const mglDataA &a,const char *stl="",mrealsVal=NAN,const char *opt="") - Метод класса
mglGraph:voidContZ (const mglDataA &a,const char *stl="",mrealsVal=NAN,const char *opt="") - Функция С:
voidmgl_cont_x (HMGLgr,HCDTa,const char *stl,mrealsVal,const char *opt) - Функция С:
voidmgl_cont_y (HMGLgr,HCDTa,const char *stl,mrealsVal,const char *opt) - Функция С:
voidmgl_cont_z (HMGLgr,HCDTa,const char *stl,mrealsVal,const char *opt) Эти функции рисуют линии уровня на x, y или z плоскостях. Если a – 3d массив, то выполняется интерполяция к заданному срезу sVal. Опция
valueзадает число контуров. Функции полезны для создания проекций 3D массивов на оси координат. См. также ContFXYZ, DensXYZ, cont, Data manipulation. См. раздел cont_xyz sample, для примеров кода и графика.
- Метод класса
mglGraph:voidContX (const mglDataA &v,const mglDataA &a,const char *stl="",mrealsVal=NAN,const char *opt="") - Метод класса
mglGraph:voidContY (const mglDataA &v,const mglDataA &a,const char *stl="",mrealsVal=NAN,const char *opt="") - Метод класса
mglGraph:voidContZ (const mglDataA &v,const mglDataA &a,const char *stl="",mrealsVal=NAN,const char *opt="") - Функция С:
voidmgl_cont_x_val (HMGLgr,HCDTv,HCDTa,const char *stl,mrealsVal,const char *opt) - Функция С:
voidmgl_cont_y_val (HMGLgr,HCDTv,HCDTa,const char *stl,mrealsVal,const char *opt) - Функция С:
voidmgl_cont_z_val (HMGLgr,HCDTv,HCDTa,const char *stl,mrealsVal,const char *opt) Аналогично предыдущему с ручным заданием значений для линий уровня.
- Команда MGL: contfx dat ['sch'=''
sval=nan] - Команда MGL: contfy dat ['sch'=''
sval=nan] - Команда MGL: contfz dat ['sch'=''
sval=nan] - Метод класса
mglGraph:voidContFX (const mglDataA &a,const char *stl="",mrealsVal=NAN,const char *opt="") - Метод класса
mglGraph:voidContFY (const mglDataA &a,const char *stl="",mrealsVal=NAN,const char *opt="") - Метод класса
mglGraph:voidContFZ (const mglDataA &a,const char *stl="",mrealsVal=NAN,const char *opt="") - Функция С:
voidmgl_contf_x (HMGLgr,HCDTa,const char *stl,mrealsVal,const char *opt) - Функция С:
voidmgl_contf_y (HMGLgr,HCDTa,const char *stl,mrealsVal,const char *opt) - Функция С:
voidmgl_contf_z (HMGLgr,HCDTa,const char *stl,mrealsVal,const char *opt) Эти функции рисуют закрашенные контуры уровня на x, y или z плоскостях. Если a – 3d массив, то выполняется интерполяция к заданному срезу sVal. Опция
valueзадает число контуров. Функции полезны для создания проекций 3D массивов на оси координат. См. также ContFXYZ, DensXYZ, cont, Data manipulation. См. раздел contf_xyz sample, для примеров кода и графика.
- Метод класса
mglGraph:voidContFX (const mglDataA &v,const mglDataA &a,const char *stl="",mrealsVal=NAN,const char *opt="") - Метод класса
mglGraph:voidContFY (const mglDataA &v,const mglDataA &a,const char *stl="",mrealsVal=NAN,const char *opt="") - Метод класса
mglGraph:voidContFZ (const mglDataA &v,const mglDataA &a,const char *stl="",mrealsVal=NAN,const char *opt="") - Функция С:
voidmgl_contf_x_val (HMGLgr,HCDTv,HCDTa,const char *stl,mrealsVal,const char *opt) - Функция С:
voidmgl_contf_y_val (HMGLgr,HCDTv,HCDTa,const char *stl,mrealsVal,const char *opt) - Функция С:
voidmgl_contf_z_val (HMGLgr,HCDTv,HCDTa,const char *stl,mrealsVal,const char *opt) Аналогично предыдущему с ручным заданием значений для линий уровня.
- Команда MGL: fplot 'y(x)' ['pen'='']
- Метод класса
mglGraph:voidFPlot (const char *eqY,const char *pen="",const char *opt="") - Функция С:
voidmgl_fplot (HMGLgr,const char *eqY,const char *pen,const char *opt) Рисует функцию ‘eqY(x)’ в плоскости z равно минимальному значению оси z с координатой ‘x’ в диапазоне осей координат. Опция
valueзадает начальное число точек. См. также plot.
- Команда MGL: fplot 'x(t)' 'y(t)' 'z(t)' ['pen'='']
- Метод класса
mglGraph:voidFPlot (const char *eqX,const char *eqY,const char *eqZ,const char *pen,const char *opt="") - Функция С:
voidmgl_fplot_xyz (HMGLgr,const char *eqX,const char *eqY,const char *eqZ,const char *pen,const char *opt) Рисует параметрическую кривую {‘eqX(t)’, ‘eqY(t)’, ‘eqZ(t)’}, где координата ‘t’ меняется в диапазоне [0, 1]. Опция
valueзадает начальное число точек. См. также plot.
- Команда MGL: fsurf 'z(x,y)' ['sch'='']
- Метод класса
mglGraph:voidFSurf (const char *eqZ,const char *sch="",const char *opt=""); - Функция С:
voidmgl_fsurf (HMGLgr,const char *eqZ,const char *sch,const char *opt); Рисует поверхность ‘eqY(x,y)’ с координатами ‘x’, ‘y’ в диапазоне
xrange, yrange. Опцияvalueзадает число точек. См. также surf.
- Команда MGL: fsurf 'x(u,v)' 'y(u,v)' 'z(u,v)' ['sch'='']
- Метод класса
mglGraph:voidFSurf (const char *eqX,const char *eqY,const char *eqZ,const char *sch="",const char *opt="") - Функция С:
voidmgl_fsurf_xyz (HMGLgr,const char *eqX,const char *eqY,const char *eqZ,const char *sch,const char *opt) Рисует параметрическую поверхность {‘eqX(u,v)’, ‘eqY(u,v)’, ‘eqZ(u,v)’}, где координаты ‘u’, ‘v’ меняются в диапазоне [0, 1]. Опция
valueзадает число точек. См. также surf.
- Команда MGL: triplot idat xdat ydat ['sch'='']
- Команда MGL: triplot idat xdat ydat zdat ['sch'='']
- Команда MGL: triplot idat xdat ydat zdat cdat ['sch'='']
- Метод класса
mglGraph:voidTriPlot (const mglDataA &id,const mglDataA &x,const mglDataA &y,const char *sch="",const char *opt="") - Метод класса
mglGraph:voidTriPlot (const mglDataA &id,const mglDataA &x,const mglDataA &y,const mglDataA &z,const mglDataA &c,const char *sch="",const char *opt="") - Метод класса
mglGraph:voidTriPlot (const mglDataA &id,const mglDataA &x,const mglDataA &y,const mglDataA &z,const char *sch="",const char *opt="") - Функция С:
voidmgl_triplot_xy (HMGLgr,HCDTid,HCDTx,HCDTy,const char *sch,const char *opt) - Функция С:
voidmgl_triplot_xyz (HMGLgr,HCDTid,HCDTx,HCDTy,HCDTz,const char *sch,const char *opt) - Функция С:
voidmgl_triplot_xyzc (HMGLgr,HCDTid,HCDTx,HCDTy,HCDTz,HCDTc,const char *sch,const char *opt) Рисует поверхность из треугольников. Вершины треугольников задаются индексами id в массиве точек {x[i], y[i], z[i]}. Строка sch задает цветовую схему. Если строка содержит ‘#’, то рисуется сетчатая поверхность. Размер по 1-му индексу массива id должен быть 3 или больше. Массивы x, y, z должны иметь одинаковые размеры. Массив c задает цвет треугольников (если id.ny=c.nx) или цвет вершин (если x.nx=c.nx). См. также dots, crust, quadplot, triangulation. См. раздел triplot sample, для примеров кода и графика.
- Команда MGL: tricont vdat idat xdat ydat zdat cdat ['sch'='']
- Команда MGL: tricont vdat idat xdat ydat zdat ['sch'='']
- Команда MGL: tricont idat xdat ydat zdat ['sch'='']
- Метод класса
mglGraph:voidTriCont (const mglDataA &id,const mglDataA &x,const mglDataA &y,const mglDataA &z,const mglDataA &c,const char *sch="",const char *opt="") - Метод класса
mglGraph:voidTriCont (const mglDataA &id,const mglDataA &x,const mglDataA &y,const mglDataA &z,const char *sch="",const char *opt="") - Метод класса
mglGraph:voidTriContV (const mglDataA &v,const mglDataA &id,const mglDataA &x,const mglDataA &y,const mglDataA &z,const mglDataA &c,const char *sch="",const char *opt="") - Метод класса
mglGraph:voidTriContV (const mglDataA &v,const mglDataA &id,const mglDataA &x,const mglDataA &y,const mglDataA &z,const char *sch="",const char *opt="") - Функция С:
voidmgl_tricont_xyzc (HMGLgr,HCDTid,HCDTx,HCDTy,HCDTz,HCDTc,const char *sch,const char *opt) - Функция С:
voidmgl_tricont_xyz (HMGLgr,HCDTid,HCDTx,HCDTy,HCDTz,const char *sch,const char *opt) - Функция С:
voidmgl_tricont_xyzcv (HMGLgr,HCDTv,HCDTid,HCDTx,HCDTy,HCDTz,HCDTc,const char *sch,const char *opt) - Функция С:
voidmgl_tricont_xyzv (HMGLgr,HCDTv,HCDTid,HCDTx,HCDTy,HCDTz,const char *sch,const char *opt) Рисует линии уровня поверхности из треугольников при z=v[k] (или при z равном минимальному значению оси z если sch содержит ‘_’). Вершины треугольников задаются индексами id в массиве точек {x[i], y[i], z[i]}. Если аргуент v не задан, то используется массив из num элементов равно распределенных в диапазоне изменения цвета. Здесь num равен значению параметра
valueв опциях opt (по умолчанию 7). Строка sch задает цветовую схему. Размер по 1-му индексу массива id должен быть 3 или больше. Массивы x, y, z должны иметь одинаковые размеры. Массив c задает цвет треугольников (если id.ny=c.nx) или цвет вершин (если x.nx=c.nx). См. также triplot, cont, triangulation.
- Команда MGL: quadplot idat xdat ydat ['sch'='']
- Команда MGL: quadplot idat xdat ydat zdat ['sch'='']
- Команда MGL: quadplot idat xdat ydat zdat cdat ['sch'='']
- Метод класса
mglGraph:voidQuadPlot (const mglDataA &id,const mglDataA &x,const mglDataA &y,const char *sch="",const char *opt="") - Метод класса
mglGraph:voidQuadPlot (const mglDataA &id,const mglDataA &x,const mglDataA &y,const mglDataA &z,const mglDataA &c,const char *sch="",const char *opt="") - Метод класса
mglGraph:voidQuadPlot (const mglDataA &id,const mglDataA &x,const mglDataA &y,const mglDataA &z,const char *sch="",const char *opt="") - Функция С:
voidmgl_quadplot_xy (HMGLgr,HCDTid,HCDTx,HCDTy,const char *sch,const char *opt) - Функция С:
voidmgl_quadplot_xyz (HMGLgr,HCDTid,HCDTx,HCDTy,HCDTz,const char *sch,const char *opt) - Функция С:
voidmgl_quadplot_xyzc (HMGLgr,HCDTid,HCDTx,HCDTy,HCDTz,HCDTc,const char *sch,const char *opt) Рисует поверхность из четырёхугольников. Вершины четырёхугольников задаются индексами id в массиве точек {x[i], y[i], z[i]}. Строка sch задает цветовую схему. Если строка содержит ‘#’, то рисуется сетчатая поверхность. Размер по 1-му индексу массива id должен быть 4 или больше. Массивы x, y, z должны иметь одинаковые размеры. Массив c задает цвет четырёхугольников (если id.ny=c.nx) или цвет вершин (если x.nx=c.nx). См. также triplot. См. раздел triplot sample, для примеров кода и графика.
- Команда MGL: dots xdat ydat zdat ['sch'='']
- Команда MGL: dots xdat ydat zdat adat ['sch'='']
- Метод класса
mglGraph:voidDots (const mglDataA &x,const mglDataA &y,const mglDataA &z,const char *sch="",const char *opt="") - Метод класса
mglGraph:voidDots (const mglDataA &x,const mglDataA &y,const mglDataA &z,const mglDataA &a,const char *sch="",const char *opt="") - Метод класса
mglGraph:voidDots (const mglDataA &x,const mglDataA &y,const mglDataA &z,const mglDataA &c,const mglDataA &a,const char *sch="",const char *opt="") - Функция С:
voidmgl_dots (HMGLgr,HCDTx,HCDTy,HCDTz,const char *sch,const char *opt) - Функция С:
voidmgl_dots_a (HMGLgr,HCDTx,HCDTy,HCDTz,HCDTa,const char *sch,const char *opt) - Функция С:
voidmgl_dots_ca (HMGLgr,HCDTx,HCDTy,HCDTz,HCDTc,HCDTa,const char *sch,const char *opt) Рисует произвольно расположенные точки {x[i], y[i], z[i]}. Строка sch задает цветовую схему и тип маркеров. Если определёны массивы c, a то они задают цвет и прозрачность точек соответственно. Непрозрачные точки с заданным цветом можно нарисовать с помощью tens, используя стиль ‘ .’. Массивы x, y, z, a должны иметь одинаковые размеры. См. также crust, tens, mark, plot. См. раздел dots sample, для примеров кода и графика.
- Команда MGL: crust xdat ydat zdat ['sch'='']
- Метод класса
mglGraph:voidCrust (const mglDataA &x,const mglDataA &y,const mglDataA &z,const char *sch="",const char *opt="") - Функция С:
voidmgl_crust (HMGLgr,HCDTx,HCDTy,HCDTz,const char *sch,const char *opt) Реконструирует и рисует поверхность по произвольно расположенным точкам {x[i], y[i], z[i]}. Опция value задает радиус ошибки (увеличите для удаления дыр). Строка sch задает цветовую схему. Если строка содержит ‘#’, то рисуется сетчатая поверхность. Массивы x, y, z должны иметь одинаковые размеры. См. также dots, triplot.
Next: Data manipulation, Previous: Other plotting, Up: MathGL core [Contents][Index]
4.17 Nonlinear fitting
Эти функции подбирают параметры функции для наилучшей аппроксимации данных, т.е. минимизируют сумму \sum_i (f(x_i, y_i, z_i) - a_i)^2/s_i^2. При этом аппроксимирующая функция ‘f’ может зависеть от одного аргумента ‘x’ (1D случай), от двух аргументов ‘x,y’ (2D случай) или от трех аргументов ‘x,y,z’ (3D случай). Функция ‘f’ также может зависеть от параметров. Список параметров задается строкой var (например, ‘abcd’). Обычно пользователь должен предоставить начальные значения параметров в переменной ini. Однако, при его отсутствии используются нулевые значения. Параметр print=true включает вывод найденной формулы в Message (см. Error handling).
Функции Fit() и FitS() не рисуют полученные массивы. Они заполняют массив fit по формуле ‘f’ с найденными коэффициентами и возвращают \chi^2 ошибку аппроксимации. При этом, координаты ‘x,y,z’ равно распределены в диапазоне осей координат. Число точек в fit определяется опцией value (по умолчанию mglFitPnts=100). Функции используют библиотеку GSL. См. раздел Nonlinear fitting hints, для примеров кода и графика.
- Команда MGL: fits res adat sdat 'func' 'var' [ini=0]
- Команда MGL: fits res xdat adat sdat 'func' 'var' [ini=0]
- Команда MGL: fits res xdat ydat adat sdat 'func' 'var' [ini=0]
- Команда MGL: fits res xdat ydat zdat adat sdat 'func' 'var' [ini=0]
- Метод класса
mglGraph:mglDataFitS (const mglDataA &a,const mglDataA &s,const char *func,const char *var,const char *opt="") - Метод класса
mglGraph:mglDataFitS (const mglDataA &a,const mglDataA &s,const char *func,const char *var,mglData &ini,const char *opt="") - Метод класса
mglGraph:mglDataFitS (const mglDataA &x,const mglDataA &a,const mglDataA &s,const char *func,const char *var,const char *opt="") - Метод класса
mglGraph:mglDataFitS (const mglDataA &x,const mglDataA &a,const mglDataA &s,const char *func,const char *var,mglData &ini,const char *opt="") - Метод класса
mglGraph:mglDataFitS (const mglDataA &x,const mglDataA &y,const mglDataA &a,const mglDataA &s,const char *func,const char *var,const char *opt="") - Метод класса
mglGraph:mglDataFitS (const mglDataA &x,const mglDataA &y,const mglDataA &a,const mglDataA &s,const char *func,const char *var,mglData &ini,const char *opt="") - Метод класса
mglGraph:mglDataFitS (const mglDataA &x,const mglDataA &y,const mglDataA &z,const mglDataA &a,const mglDataA &s,const char *func,const char *var,const char *opt="") - Метод класса
mglGraph:mglDataFitS (const mglDataA &x,const mglDataA &y,const mglDataA &z,const mglDataA &a,const mglDataA &s,const char *func,const char *var,mglData &ini,const char *opt="") - Функция С:
HMDTmgl_fit_ys (HMGLgr,HCDTa,HCDTs,const char *func,const char *var,HMDTini,const char *opt) - Функция С:
HMDTmgl_fit_xys (HMGLgr,HCDTx,HCDTa,HCDTs,const char *func,const char *var,HMDTini,const char *opt) - Функция С:
HMDTmgl_fit_xyzs (HMGLgr,HCDTx,HCDTy,HCDTa,HCDTs,const char *func,const char *var,HMDTini,const char *opt) - Функция С:
HMDTmgl_fit_xyzas (HMGLgr,HCDTx,HCDTy,HCDTz,HCDTa,HCDTs,const char *func,const char *var,HMDTini,const char *opt) "Подгоняют" формулу вдоль x-, y- и z-направлений для 3d массива заданного параметрически a[i,j,k](x[i,j,k], y[i,j,k], z[i,j,k]) с весовым множителем s[i,j,k].
- Команда MGL: fit res adat 'func' 'var' [ini=0]
- Команда MGL: fit res xdat adat 'func' 'var' [ini=0]
- Команда MGL: fit res xdat ydat adat 'func' 'var' [ini=0]
- Команда MGL: fit res xdat ydat zdat adat 'func' 'var' [ini=0]
- Метод класса
mglGraph:mglDataFit (const mglDataA &a,const char *func,const char *var,const char *opt="") - Метод класса
mglGraph:mglDataFit (const mglDataA &a,const char *func,const char *var,mglData &ini,const char *opt="") - Метод класса
mglGraph:mglDataFit (const mglDataA &x,const mglDataA &a,const char *func,const char *var,const char *opt="") - Метод класса
mglGraph:mglDataFit (const mglDataA &x,const mglDataA &a,const char *func,const char *var,mglData &ini,const char *opt="") - Метод класса
mglGraph:mglDataFit (const mglDataA &x,const mglDataA &y,const mglDataA &a,const char *func,const char *var,const char *opt="") - Метод класса
mglGraph:mglDataFit (const mglDataA &x,const mglDataA &y,const mglDataA &a,const char *func,const char *var,mglData &ini,const char *opt="") - Метод класса
mglGraph:mglDataFit (const mglDataA &x,const mglDataA &y,const mglDataA &z,const mglDataA &a,const char *func,const char *var,const char *opt="") - Метод класса
mglGraph:mglDataFit (const mglDataA &x,const mglDataA &y,const mglDataA &z,const mglDataA &a,const char *func,const char *var,mglData &ini,const char *opt="") - Функция С:
HMDTmgl_fit_y (HMGLgr,HCDTa,const char *func,const char *var,HMDTini,const char *opt) - Функция С:
HMDTmgl_fit_xy (HMGLgr,HCDTx,HCDTa,const char *func,const char *var,HMDTini,const char *opt) - Функция С:
HMDTmgl_fit_xyz (HMGLgr,HCDTx,HCDTy,HCDTa,const char *func,const char *var,HMDTini,const char *opt) - Функция С:
HMDTmgl_fit_xyza (HMGLgr,HCDTx,HCDTy,HCDTz,HCDTa,const char *func,const char *var,HMDTini,const char *opt) "Подгоняют" формулу вдоль x-, y- и z-направлений для 3d массива заданного параметрически a[i,j,k](x[i,j,k], y[i,j,k], z[i,j,k]) с весовым множителем 1.
- Метод класса
mglGraph:mglDataFit2 (const mglDataA &a,const char *func,const char *var,const char *opt="") - Метод класса
mglGraph:mglDataFit2 (mglData &fit,const mglDataA &a,const char *func,const char *var,mglData &ini,const char *opt="") - Метод класса
mglGraph:mglDataFit3 (mglData &fit,const mglDataA &a,const char *func,const char *var,const char *opt="") - Метод класса
mglGraph:mglDataFit3 (mglData &fit,const mglDataA &a,const char *func,const char *var,mglData &ini,const char *opt="") - Функция С:
HMDTmgl_fit_2 (HMGLgr,HCDTa,const char *func,const char *var,HMDTini,const char *opt) - Функция С:
HMDTmgl_fit_3 (HMGLgr,HCDTa,const char *func,const char *var,HMDTini,const char *opt) "Подгоняют" формулу вдоль всех направлений для 2d или 3d массива a с s=1 и x, y, z равно распределёнными в диапазоне осей координат.
- Команда MGL: putsfit
x y['pre'='' 'fnt'=''size=-1] - Метод класса
mglGraph:voidPutsFit (mglPointp,const char *prefix="",const char *font="",mrealsize=-1) - Функция С:
voidmgl_puts_fit (HMGLgr,mrealx,mrealy,mrealz,const char *prefix,const char *font,mrealsize) Печатает последнюю подобранную формулу с найденными коэффициентами в точке p0. Строка prefix будет напечатана перед формулой. Все другие параметры такие же как в Text printing.
- Метод класса
mglGraph:const char *GetFit () - Функция С:
const char *mgl_get_fit (HMGLgr) - Fortran процедура:
mgl_get_fit (longgr,char *out,intlen) Возвращает последнюю подобранную формулу с найденными коэффициентами.
- Метод класса
mglGraph:mrealGetFitChi () - Функция С:
mrealmgl_get_fit_chi () Возвращает величину \chi для последней подобранной формулы.
- Метод класса
mglGraph:mrealGetFitCovar () - Функция С:
mrealmgl_get_fit_covar () Возвращает ковариационную матрицу для последней подобранной формулы.
Previous: Nonlinear fitting, Up: MathGL core [Contents][Index]
4.18 Распределение данных
- Команда MGL: hist RES xdat adat
- Команда MGL: hist RES xdat ydat adat
- Команда MGL: hist RES xdat ydat zdat adat
- Метод класса
mglGraph:mglDataHist (const mglDataA &x,const mglDataA &a,const char *opt="") - Метод класса
mglGraph:mglDataHist (const mglDataA &x,const mglDataA &y,const mglDataA &a,const char *opt="") - Метод класса
mglGraph:mglDataHist (const mglDataA &x,const mglDataA &y,const mglDataA &z,const mglDataA &a,const char *opt="") - Функция С:
HMDTmgl_hist_x (HMGLgr,HCDTx,HCDTa,const char *opt) - Функция С:
HMDTmgl_hist_xy (HMGLgr,HCDTx,HCDTy,HCDTa,const char *opt) - Функция С:
HMDTmgl_hist_xyz (HMGLgr,HCDTx,HCDTy,HCDTz,HCDTa,const char *opt) Создают распределения данных. Они не рисуют данные. Функции могут быть полезны в случае когда данные пользователя определены на случайно расположенных точка (например, после PIC расчетов) и он хочет построить график, требующий регулярных данных (данных на сетках). Диапазон сеток равен диапазону осей координат. Массивы x, y, z определяют положение (координаты) точек. Массив a задает значения данных. Число точек в результате res определяется опцией
value(по умолчанию mglFitPnts=100).
- Команда MGL: fill dat 'eq'
- Команда MGL: fill dat 'eq' vdat
- Команда MGL: fill dat 'eq' vdat wdat
- Метод класса
mglGraph:voidFill (mglData &u,const char *eq,const char *opt="") - Метод класса
mglGraph:voidFill (mglData &u,const char *eq,const mglDataA &v,const char *opt="") - Метод класса
mglGraph:voidFill (mglData &u,const char *eq,const mglDataA &v,const mglDataA &w,const char *opt="") - Функция С:
voidmgl_data_fill_eq (HMGLgr,HMDTu,const char *eq,HCDTv,HCDTw,const char *opt) Заполняют значения массива ‘u’ в соответствии с формулой в строке eq. Формула – произвольное выражение, зависящее от переменных ‘x’, ‘y’, ‘z’, ‘u’, ‘v’, ‘w’. Координаты ‘x’, ‘y’, ‘z’ полагаются в диапазоне изменения осей координат. Переменная ‘u’ – значение исходного массива. Переменные ‘v’ и ‘w’ – значения массивов v, w, которые могут быть
NULL(т.е. могут быть опущены).
- Команда MGL: datagrid dat xdat ydat zdat
- Метод класса
mglGraph:voidDataGrid (mglData &u,const mglDataA &x,const mglDataA &y,const mglDataA &z,const char *opt="") - Функция С:
voidmgl_data_grid (HMGLgr,HMDTu,HCDTx,HCDTy,HCDTz,const char *opt) Заполняет значения массива ‘u’ результатом линейной интерполяции по триангулированной поверхности, найденной по произвольно расположенным точкам ‘x’, ‘y’, ‘z’. NAN значение используется для точек сетки вне триангулированной поверхности. См. раздел Making regular data, для примеров кода и графика.
- Команда MGL: refill dat xdat vdat [sl=-1]
- Команда MGL: refill dat xdat ydat vdat [sl=-1]
- Команда MGL: refill dat xdat ydat zdat vdat
- Метод класса
mglData:voidRefill (mglDataA &dat,const mglDataA &x,const mglDataA &v,longsl=-1,const char *opt="") - Метод класса
mglData:voidRefill (mglDataA &dat,const mglDataA &x,const mglDataA &y,const mglDataA &v,longsl=-1,const char *opt="") - Метод класса
mglData:voidRefill (mglDataA &dat,const mglDataA &x,const mglDataA &y,const mglDataA &z,const mglDataA &v,const char *opt="") - Функция С:
voidmgl_data_refill_gr (HMGLgr,HMDTa,HCDTx,HCDTy,HCDTz,HCDTv,longsl,const char *opt) Заполняет значениями интерполяции массива v в точках {x, y, z}={
X[i], Y[j], Z[k]} (или {x, y, z}={X[i,j,k], Y[i,j,k], Z[i,j,k]} если x, y, z не 1d массивы), гдеX,Y,Zравномерно распределены в диапазоне осей координат и имеют такой же размер как и массив dat. Если параметр sl равен 0 или положительный, то изменятся будет только sl-ый срез.
- Команда MGL: pde RES 'ham' ini_re ini_im [
dz=0.1 k0=100] - Метод класса
mglGraph:mglDataPDE (const char *ham,const mglDataA &ini_re,const mglDataA &ini_im,mrealdz=0.1,mrealk0=100,const char *opt="") - Функция С:
HMDTmgl_pde_solve (HMGLgr,const char *ham,HCDTini_re,HCDTini_im,mrealdz,mrealk0,const char *opt) Решает уравнение в частных производных du/dz = i*k0*ham(p,q,x,y,z,|u|)[u], где p=-i/k0*d/dx, q=-i/k0*d/dy – псевдо-дифференциальные оперторы. Параметры ini_re, ini_im задают действительную и мнимую часть начального распределения поля. Координаты ‘x’, ‘y’, ‘z’ полагаются в диапазоне изменения осей координат. Отмечу, ято в действительности этот диапазон увеличен на 3/2 для уменьшения отражения от границ сетки. Параметр dz задает шаг по эволюционной координате z. Сейчас используется упрощенный вид функции ham – исключены все “смешанные” члены (типа ‘x*p’->x*d/dx). Например, в 2D случае это функция вида ham = f(p,z) + g(x,z,u). Однако, коммутирующие члены (типа ‘x*q’->x*d/dy) разрешены. Переменная ‘u’ используется для амплитуды поля |u|, что позволяет решать нелинейные задачи – например уравнение Шредингера
ham="p^2 + q^2 - u^2". Вы можете задавать мнимую часть для поглощения волн, напримерham = "p^2 + i*x*(x>0)", но только для линейной зависимости от переменной ‘i’ (т.е. ham = hre+i*him). См. раздел PDE solving hints, для примеров кода и графика.
Next: Data processing, Previous: MathGL core, Up: Top [Contents][Index]
5 “Оконные” классы
Есть целый набор “оконных” классов для создания окон с графикой MathGL: mglWnd и mglGLUT для окон целиком, Fl_MathGL и QMathGL для виджетов. Все эти классы позволяют пользователю просмотривать, вращать, экспортировать рисунок. Большинство из них (кроме mglGLUT) имеют панель инструментов для упрощения изменения графика. Все оконные классы имеют схожий набор функций. Ниже приведен список классов с краткими комментариями.
Для рисования можно использовать: указатель NULL если планируется обновлять график вручную, глобальную функцию типа int draw( или HMGL gr, void *p)int draw(, или экземпляр класса, производного от mglDraw class. Этот класс определен в mglGraph *gr)#include <mgl2/wnd.h> и имеет 2 основных виртуальных метода:
class mglDraw
{
public:
virtual int Draw(mglGraph *) { return 0; };
virtual void Reload() {};
};
Вам следует наследовать свой класс от mglDraw и определить один или оба метода.
Непосредственно окна можно создать используя один из следующих классов (см. Using MathGL window для примеров).
- Конструктор класса
mglFLTK: mglFLTK (const char *title="MathGL") - Конструктор класса
mglFLTK: mglFLTK (int(*draw)(HMGLgr,void *p),const char *title="MathGL",void *par=NULL,void(*reload)(HMGLgr,void *p)=0) - Конструктор класса
mglFLTK: mglFLTK (int(*draw)(mglGraph *gr),const char *title="MathGL") - Конструктор класса
mglFLTK: mglFLTK (mglDraw *draw,const char *title="MathGL") - Функция С:
HMGLmgl_create_graph_fltk (int(*draw)(HMGLgr,void *p),const char *title,void *par,void(*reload)(HMGLgr,void *p)) -
Создает FLTK окно для вывода графика. Параметр draw – указатель (имя) функции рисования. Есть возможность создания нескольких кадров вначале (требует больше памяти) и их быстрая анимации в дальнейшем. В этом случае функция draw должна возвращать число кадров или ноль для рисования по запросу. Замечу, что draw может быть равна
NULLдля отображения статической (текущей) картинки. Параметр title задает заголовок окна. Параметр par содержит указатель на данные, передаваемые функции рисования draw. FLTK окна обеспечивают быстрое рисование и хорошо поддерживают многопоточность.
- Метод класса
mglWnd:intRunThr () - Функция С:
intmgl_fltk_thr () Запускает цикл обработки сообщений в отдельном потоке. В данный момент работает только для окон FLTK.
- Конструктор класса
mglQT: mglQT (const char *title="MathGL") - Конструктор класса
mglQT: mglQT (int(*draw)(HMGLgr,void *p),const char *title="MathGL",void *par=NULL,void(*reload)(HMGLgr,void *p)=0) - Конструктор класса
mglQT: mglQT (int(*draw)(mglGraph *gr),const char *title="MathGL") - Конструктор класса
mglQT: mglQT (mglDraw *draw,const char *title="MathGL") - Функция С:
HMGLmgl_create_graph_qt (int(*draw)(HMGLgr,void *p),const char *title,void *par,void(*reload)(HMGLgr,void *p)) -
Создает Qt окно для вывода графика. Параметр draw – указатель (имя) функции рисования. Есть возможность создания нескольких кадров вначале (требует больше памяти) и их быстрая анимации в дальнейшем. В этом случае функция draw должна возвращать число кадров или ноль для рисования по запросу. Замечу, что draw может быть равна
NULLдля отображения статической (текущей) картинки. Параметр title задает заголовок окна. Параметр par содержит указатель на данные, передаваемые функции рисования draw.
- Конструктор класса
mglGLUT: mglGLUT (const char *title="MathGL") - Конструктор класса
mglGLUT: mglGLUT (int(*draw)(HMGLgr,void *p),const char *title="MathGL",void *par=NULL,void(*reload)(HMGLgr,void *p)=0) - Конструктор класса
mglGLUT: mglGLUT (int(*draw)(mglGraph *gr),const char *title="MathGL") - Конструктор класса
mglGLUT: mglGLUT (mglDraw *draw,const char *title="MathGL") - Функция С:
HMGLmgl_create_graph_glut (int(*draw)(HMGLgr,void *p),const char *title,void *par,void(*reload)(HMGLgr,void *p)) -
Создает окно для вывода графика. Параметр draw – указатель (имя) функции рисования. Есть возможность создания нескольких кадров вначале (требует больше памяти) и их быстрая анимации в дальнейшем. В этом случае функция draw должна возвращать число кадров или ноль для рисования по запросу. Замечу, что draw может быть равна
NULLдля отображения статической (текущей) картинки. Параметр title задает заголовок окна. Параметр par содержит указатель на данные, передаваемые функции рисования draw. Параметр kind может иметь следующие значения: ‘0’ – использовать окно FLTK, ‘1’ – использовать окно Qt.В окне просмотра можно использовать клавиши: ’a’, ’d’, ’w’, ’s’ для вращения; ’,’, ’.’ для просмотра предыдущего и следующего кадров; ’r’ для переключения прозрачности; ’f’ для переключения оспещенности; ’x’ для закрытия окна.
| • mglWnd class: | ||
| • mglDraw class: | ||
| • Fl_MathGL class: | ||
| • QMathGL class: | ||
| • wxMathGL class: |
Next: Fl_MathGL class, Up: Widget classes [Contents][Index]
5.1 Класс mglWnd
Это абстрактный класс производный от класса mglGraph (см. MathGL core). Он определен в #include <mgl2/wnd.h>. Класс содержит методы для создания и управления окном, содержащим графику MathGL. Производные от него классы существует отдельно для каждой библиотеки виджетов: mglQT в #include <mgl2/qt.h>, mglFLTK в #include <mgl2/fltk.h>.
- Метод класса
mglWnd:intRun () - Функция С:
intmgl_qt_run () - Функция С:
intmgl_fltk_run () Запускает цикл обработки сообщений. Обычно эта функция должна вызываться в отдельном потоке или последней функцией в
main().
- Метод класса
mglWnd:voidSetDrawFunc (int(*draw)(HMGLgr,void *p),void *par=NULL,void(*reload)(void *p)=NULL) - Метод класса
mglWnd:voidSetDrawFunc (int(*draw)(mglGraph *gr)) - Метод класса
mglWnd:voidSetDrawFunc (mglDraw *obj) - Функция С:
voidmgl_wnd_set_func (HMGLgr,int(*draw)(HMGLgr,void *p),void *par,void(*reload)(void *p)) Устанавливает функцию, которая будет вызвана при перерисовке (draw) и при повторной загрузке данных (reload), или объект obj класса, производного от
mglDraw.
- Метод класса
mglWnd:voidSetClickFunc (void(*func)(HMGLgr,void *p)) - Функция С:
voidmgl_set_click_func (void(*func)(HMGLgr,void *p)) Устанавливает функцию, которая будет вызвана при щелчке мышью.
- Method on
mglWnd:voidSetMutex(pthread_mutex_t *mutex) - C function:
voidmgl_wnd_set_mutex(HMGLgr,pthread_mutex_t *mutex) Устанавливает внешний mutex для блокировки/разблокировки внешних вычислений с помощью меню или кнопок окна. Функция вызывается автоматически при использовании mglDraw class.
- Метод класса
mglWnd:voidToggleAlpha () - Функция С:
voidmgl_wnd_toggle_alpha (HMGLgr) Включает/выключает прозрачность, но не перекрывает ее включение в пользовательской функции рисования.
- Метод класса
mglWnd:voidToggleLight () - Функция С:
voidmgl_wnd_toggle_light (HMGLgr) Включает/выключает освещение, но не перекрывает его включение в пользовательской функции рисования.
- Метод класса
mglWnd:voidToggleRotate () - Функция С:
voidmgl_wnd_toggle_rotate (HMGLgr) Включает/выключает вращение мышкой. Нажатая левая кнопка используется для вращения, средняя для сдвига, правая для приближения/перспективы.
- Метод класса
mglWnd:voidToggleZoom () - Функция С:
voidmgl_wnd_toggle_zoom (HMGLgr) Включает/выключает приближение мышкой. Выделите прямоугольную область и она будет приближена.
- Метод класса
mglWnd:voidToggleNo () - Функция С:
voidmgl_wnd_toggle_no (HMGLgr) Выключает вращение и приближение мышкой, а также восстанавливает исходный вид графика.
- Метод класса
mglWnd:voidUpdate () - Функция С:
voidmgl_wnd_update (HMGLgr) Обновляет содержимое окна. Функция полезна при ручном обновлении содержимого, пока долгий расчет идет в параллельном потоке.
- Метод класса
mglWnd:voidReLoad () - Функция С:
voidmgl_wnd_reload (HMGLgr) Перегружает данные и обновляет рисунок. Функция также обновляет число кадров, которое создает функция рисования.
- Метод класса
mglWnd:voidAdjust () - Функция С:
voidmgl_wnd_adjust (HMGLgr) Подгоняет размер рисунка под размер окна.
- Метод класса
mglWnd:voidNextFrame () - Функция С:
voidmgl_wnd_next_frame (HMGLgr) Показывает следующий кадр, если он есть.
- Метод класса
mglWnd:voidPrevFrame () - Функция С:
voidmgl_wnd_prev_frame (HMGLgr) Показывает предыдущий кадр, если он есть.
- Метод класса
mglWnd:voidAnimation () - Функция С:
voidmgl_wnd_animation (HMGLgr) Запускает/останавливает анимацию кадров.
- Метод класса
mglWnd:voidSetDelay (doubledt) - Функция С:
voidmgl_wnd_set_delay (HMGLgr,doubledt) Задает задержку при анимации в секундах. По умолчанию интервал – 1 секунда.
- Метод класса
mglWnd:doubleGetDelay () - Функция С:
doublemgl_wnd_get_delay (HMGLgr) Возвращает задержку при анимации в секундах.
- Метод класса
mglWnd:voidSetup (boolclfupd=true,boolshowpos=false) - Функция С:
voidmgl_setup_window (HMGLgr,boolclfupd,boolshowpos) Включает/выключает:
- очистку рисунка перед Update();
- показ позиции щелчка мыши на рисунке.
- Метод класса
mglWnd:mglPointLastMousePos () - Функция С:
voidmgl_get_last_mouse_pos (HMGLgr,mreal *x,mreal *y,mreal *z) Возвращает положение щелчка мыши.
- Method on
mglWnd:void *Widget () - C function:
void *mgl_fltk_widget (HMGLgr) - C function:
void *mgl_qt_widget (HMGLgr) Возвращает указатель на виджет (Fl_MathGL class or QMathGL class), используемый для рисования.
Next: Fl_MathGL class, Previous: mglWnd class, Up: Widget classes [Contents][Index]
5.2 mglDraw class
This class provide base functionality for callback drawing and running calculation in separate thread. It is defined in #include <mgl2/wnd.h>. You should make inherited class and implement virtual functions if you need it.
- Virtual method on
mglDraw:intDraw (mglGraph *gr) This is callback drawing function, which will be called when any redrawing is required for the window. There is support of a list of plots (frames). So as one can prepare a set of frames at first and redraw it fast later (but it requires more memory). Function should return positive number of frames for the list or zero if it will plot directly.
- Virtual method on
mglDraw:voidReload () This is callback function, which will be called if user press menu or toolbutton to reload data.
- Virtual method on
mglDraw:voidClick () This is callback function, which will be called if user click mouse.
- Virtual method on
mglDraw:voidCalc () This is callback function, which will be called if user start calculations in separate thread by calling
mglDraw::Run()function. It should periodically callmglDraw::Check()function to check if calculations should be paused.
- Method on
mglDraw:voidRun () Runs
mglDraw::Calc()function in separate thread. It also initializemglDraw::thrvariable and unlockmglDraw::mutex. Function is present only if FLTK support for widgets was enabled.
- Method on
mglDraw:voidCancel () Cancels thread with calculations. Function is present only if FLTK support for widgets was enabled.
- Method on
mglDraw:voidPause () Pauses thread with calculations by locking
mglDraw::mutex. You should callmglDraw::Continue()to continue calculations. Function is present only if FLTK support for widgets was enabled.
- Method on
mglDraw:voidContinue () Continues calculations by unlocking
mglDraw::mutex. Function is present only if FLTK support for widgets was enabled.
- Method on
mglDraw:voidContinue () Checks if calculations should be paused and pause it. Function is present only if FLTK support for widgets was enabled.
Next: QMathGL class, Previous: mglDraw class, Up: Widget classes [Contents][Index]
5.3 Класс Fl_MathGL
Класс реализует элемент интерфейса FLTK для отображения графики MathGL. Он определен в #include <mgl2/Fl_MathGL.h>.
- Method on Fl_MathGL:
voidset_draw (int(*draw)(HMGLgr,void *p)) - Method on Fl_MathGL:
voidset_draw (int(*draw)(mglGraph *gr)) - Method on Fl_MathGL:
voidset_draw (mglDraw *draw) Устанавливает функцию рисования как глобальную функцию или как функцию член класса, производного от
mglDraw. Поддерживается список графиков (кадров), так что можно вначале их нарисовать (требует довольно много памяти), а потом достаточно быстро отображать. Функция должна возвращать положительное число создаваемых кадров или ноль для непосредственного рисования. Параметр par содержит указатель на данные пользователя, передаваемый функции рисования draw.
- Method on Fl_MathGL:
mglDraw *get_class () Указатель на экземпляр класса
mglDrawилиNULLесли отсутствует.
- Method on Fl_MathGL:
voidset_angle (mrealt,mrealp) Задает углы для дополнительного вращения графика.
- Method on Fl_MathGL:
voidset_flag (intf) Задает битовые флаги для: 1 - прозрачности, 2 - освещения.
- Method on Fl_MathGL:
voidset_state (boolz,boolr) Задает флаги обработки движений мыши: z=
true– разрешает приближение выделения, r=trueразрешает вращение/сдвиг/приближение/перспективу.
- Method on Fl_MathGL:
voidset_zoom (mrealX1,mrealY1,mrealX2,mrealY2) Задает область приближения.
- Method on Fl_MathGL:
voidget_zoom (mreal *X1,mreal *Y1,mreal *X2,mreal *Y2) Возвращает область приближения.
- Method on Fl_MathGL:
voidset_popup (const Fl_Menu_Item *pmenu,Fl_Widget *w,void *v) Задает указатель на всплывающее меню.
- Method on Fl_MathGL:
voidset_graph (mglCanvas *gr) - Method on Fl_MathGL:
voidset_graph (mglGraph *gr) Задает экземпляр класс для рисования вместо встроеного. Fl_MathGL автоматически удалит его при удалении виджета и при новом вызове
set_graph().
- Method on Fl_MathGL:
voidset_show_warn (boolval) Флаг показа окна с сообщениями после выполнения скрипта.
- Method on Fl_MathGL:
voidset_handle_key (boolval) Вкл/выкл обработку нажатий клавиш (как в mglview, по умолчанию выкл).
- Widget option of Fl_MathGL:
Fl_Valuator *tet_val Указатель на внешний элемент управления для изменения угла tet.
- Widget option of Fl_MathGL:
Fl_Valuator *phi_val Указатель на внешний элемент управления для изменения угла phi.
Next: wxMathGL class, Previous: Fl_MathGL class, Up: Widget classes [Contents][Index]
5.4 Класс QMathGL
Класс реализует элемент интерфейса Qt для отображения графики MathGL. Он определен в #include <mgl2/qt.h>.
- Method on QMathGL:
voidsetDraw (mglDraw *dr) Задает функцию рисования из класса производного от
mglDraw.
- Method on QMathGL:
voidsetDraw (int (*draw)(mglBase *gr,void *p),void *par=NULL) - Method on QMathGL:
voidsetDraw (int (*draw)(mglGraph *gr)) Задает функцию рисования draw. Поддерживается список графиков (кадров), так что можно вначале их нарисовать (требует довольно много памяти), а потом достаточно быстро отображать. Функция должна возвращать положительное число создаваемых кадров или ноль для непосредственного рисования. Параметр par содержит указатель на данные пользователя, передаваемый функции рисования draw.
- Method on QMathGL:
voidsetGraph (mglCanvas *gr) - Method on QMathGL:
voidsetGraph (mglGraph *gr) Устанавливает указатель на внешний экземпляр класса для рисования (вместо встроенного). Отмечу, что QMathGL автоматически удалит этот объект при удалении элемента интерфейса или при новом вызове
setGraph().
- Slot on
QMathGL:voidrefresh () Перерисовывает (обновляет) элемент управления без вызова функции рисования.
- Slot on
QMathGL:voidsetGrid (boolval) Включает/выключает рисование сетки абсолютных координат на графике.
- Slot on
QMathGL:voidrestore () Восстанавливает приближение и поворот графика в значения по умолчанию.
- Slot on
QMathGL:voidexportPNGs (QStringfname="") Сохраняет текущий рисунок в PNG файл без прозрачности.
- Slot on
QMathGL:voidexportTEX (QStringfname="") Сохраняет текущий рисунок в векторный LaTeX/Tikz файл.
- Slot on
QMathGL:voidexportXYZ (QStringfname="") Сохраняет текущий рисунок в векторный XYZ/XYZL/XYZF файл.
- Slot on
QMathGL:voidexportOBJ (QStringfname="") Сохраняет текущий рисунок в векторный OBJ/MTL файл.
- Slot on
QMathGL:voidsetUsePrimitives (booluse) Разрешает использовать список примитивов для кадров. Это позволяет вращать/масштабировать кадры, но требует значительно больше памяти. По умолчанию разрешено (=
true).
- Slot on
QMathGL:voidsetMGLFont (QStringpath) Восстанавливает (path=
"") или загружает файлы шрифтов.
Previous: QMathGL class, Up: Widget classes [Contents][Index]
5.5 Класс wxMathGL
Класс реализует элемент интерфейса WX для отображения графики MathGL. Он определен в #include <mgl2/wx.h>.
- Method on wxMathGL:
voidSetDraw (mglDraw *dr) Задает функцию рисования из класса производного от
mglDraw.
- Method on wxMathGL:
voidSetDraw (int (*draw)(mglBase *gr,void *p),void *par=NULL) - Method on wxMathGL:
voidSetDraw (int (*draw)(mglGraph *gr)) Задает функцию рисования draw. Поддерживается список графиков (кадров), так что можно вначале их нарисовать (требует довольно много памяти), а потом достаточно быстро отображать. Функция должна возвращать положительное число создаваемых кадров или ноль для непосредственного рисования. Параметр par содержит указатель на данные пользователя, передаваемый функции рисования draw.
- Method on wxMathGL:
voidSetGraph (mglCanvas *gr) - Method on wxMathGL:
voidSetGraph (mglGraph *gr) Устанавливает указатель на внешний экземпляр класса для рисования (вместо встроенного). Отмечу, что wxMathGL автоматически удалит этот объект при удалении элемента интерфейса или при новом вызове
setGraph().
- Method on wxMathGL:
voidRepaint () Перерисовывает (обновляет) элемент управления без вызова функции рисования.
- Method on wxMathGL:
voidRestore () Восстанавливает приближение и поворот графика в значения по умолчанию.
- Method on wxMathGL:
voidExportPNGs (QStringfname="") Сохраняет текущий рисунок в PNG файл без прозрачности.
- Method on wxMathGL:
voidExportBPS (QStringfname="") Сохраняет текущий рисунок в растровый EPS файл.
- Method on wxMathGL:
voidExportEPS (QStringfname="") Сохраняет текущий рисунок в векторный EPS файл.
- Method on wxMathGL:
voidExportSVG (QStringfname="") Сохраняет текущий рисунок в векторный SVG файл.
Next: MGL scripts, Previous: Widget classes, Up: Top [Contents][Index]
6 Обработка данных
В данной главе описываются классы mglData и mglDataC для работы с массивами действительных и комплексных данных, определённые в #include <mgl2/data.h> и #include <mgl2/datac.h> соответственно. Оба класса являются наследниками абстрактного класса mglDataA, и могут быть использованы в аргументах всех функций рисования (см. MathGL core). Классы содержат функции для выделения памяти и изменения размера данных, чтения данных из файла, численного дифференцирования, интегрирования, интерполяции и пр., заполнения по текстовой формуле и т.д. Классы позволяют работать с данными размерности не более 3 (как функции от трёх переменных – x,y,z). По умолчанию внутреннее представление данных использует тип mreal (и dual=std::complex<mreal> для mglDataC), который может быть сконфигурирован как float или double на этапе установки указав опцию --enable-double (см. Installation). Тип float удобен в силу меньшего размера занимаемой памяти и, как правило, достаточной для построения графиков точности. Однако, тип double имеет большую точность, что может быть важно, например, для осей с метками времени. Массивы которые могут быть созданы командами MGL отображаются Small Caps шрифтом (например, DAT).
| • Public variables: | ||
| • Data constructor: | ||
| • Data resizing: | ||
| • Data filling: | ||
| • File I/O: | ||
| • Make another data: | ||
| • Data changing: | ||
| • Interpolation: | ||
| • Data information: | ||
| • Operators: | ||
| • Global functions: | ||
| • Evaluate expression: | ||
| • Special data classes: |
Next: Data constructor, Up: Data processing [Contents][Index]
6.1 Переменные
- Variable of mglData:
mreal *a - Variable of mglDataC:
dual *a Указатель на массив данных. Это одномерный массив. Например, матрица [nx x ny x nz] представляется одномерным массивом длиной nx*ny*nz, где элемент с индексами {i, j, k} находится как a[i+nx*j+nx*ny*k] (индексы отсчитываются от нуля).
- Variable of mglData:
intnx - Variable of mglDataC:
longnx Размер массива по 1-ой размерности (’x’ размерности).
- Variable of mglData:
intny - Variable of mglDataC:
longny Размер массива по 2-ой размерности (’y’ размерности).
- Variable of mglData:
intnz - Variable of mglDataC:
longnz Размер массива по 3-ей размерности (’z’ размерности).
- Variable of mglData:
std::stringid - Variable of mglDataC:
std::stringid Имена колонки (или среза при nz>1) – один символ на колонку.
- Variable of mglData:
boollink - Variable of mglDataC:
boollink Флаг использования указателя на внешние данные, включает запрет на удаление массива данных.
- Variable of mglDataA:
booltemp Флаг временной переменной, которая может быть удалена в любой момент.
- Variable of mglDataA:
void (*)(void *)func Указатель на callback функцию, которая будет вызвана при удлалении данных.
- Метод класса
mglData:mrealGetVal (longi) - Метод класса
mglDataC:mrealGetVal (longi) - Метод класса
mglData:voidSetVal (mrealval,longi) - Метод класса
mglDataC:voidSetVal (mrealval,longi) Присваивает или возвращает значение используя "непрерывную" индексацию без проверки выхода за границы массива. Индекс i должен быть в диапазоне [0, nx*ny*nz-1].
- Метод класса
mglDataA:longGetNx () - Метод класса
mglDataA:longGetNy () - Метод класса
mglDataA:longGetNz () - Функция С:
longmgl_data_get_nx (HCDTdat) - Функция С:
longmgl_data_get_ny (HCDTdat) - Функция С:
longmgl_data_get_nz (HCDTdat) Возвращает размер данных в направлении x, y и z соответственно.
- Функция С:
mrealmgl_data_get_value (HCDTdat,inti,intj,intk) - Функция С:
dualmgl_datac_get_value (HCDTdat,inti,intj,intk) - Функция С:
mreal *mgl_data_value (HMDTdat,inti,intj,intk) - Функция С:
dual *mgl_datac_value (HADTdat,inti,intj,intk) - Функция С:
voidmgl_data_set_value (HMDTdat,mrealv,inti,intj,intk) - Функция С:
voidmgl_datac_set_value (HADTdat,dualv,inti,intj,intk) Присваивает или возвращает значение ячейки данных с проверкой выхода за пределы массива.
- Функция С:
voidmgl_data_set_func (mglDataA *dat,void (*func)(void *),void *par) Задает указатель на callback функцию, которая будет вызвана при удлалении данных.
- Функция С:
voidmgl_data_set_name (mglDataA *dat,const char *name) - Функция С:
voidmgl_data_set_name_w (mglDataA *dat,const wchar_t *name) Задает имя массива данных, использующееся при разборе MGL скриптов.
Next: Data resizing, Previous: Public variables, Up: Data processing [Contents][Index]
6.2 Создание и удаление данных
- Команда MGL: new DAT [
nx=1'eq'] - Команда MGL: new DAT
nx ny['eq'] - Команда MGL: new DAT
nx ny nz['eq'] - Конструктор класса
mglData: mglData (intmx=1,intmy=1,intmz=1) - Конструктор класса
mglDataC: mglDataC (intmx=1,intmy=1,intmz=1) - Функция С:
HMDTmgl_create_data () - Функция С:
HMDTmgl_create_data_size (intmx,intmy,intmz) Выделяет память для массива данных и заполняет её нулями. Если указана формула eq, то данные заполняются также как при использовании fill.
- Команда MGL: copy DAT dat2 ['eq'='']
- Команда MGL: copy DAT
val - Конструктор класса
mglData: mglData (const mglData &dat2) - Конструктор класса
mglData: mglData (const mglDataA *dat2) - Конструктор класса
mglData: mglData (intsize,const mreal *dat2) - Конструктор класса
mglData: mglData (intsize,intcols,const mreal *dat2) - Конструктор класса
mglData: mglData (intsize,const double *dat2) - Конструктор класса
mglData: mglData (intsize,intcols,const double *dat2) - Конструктор класса
mglData: mglData (const double *dat2,intsize) - Конструктор класса
mglData: mglData (const double *dat2,intsize,intcols) - Конструктор класса
mglDataC: mglDataC (const mglDataA &dat2) - Конструктор класса
mglDataC: mglDataC (const mglDataA *dat2) - Конструктор класса
mglDataC: mglDataC (intsize,const float *dat2) - Конструктор класса
mglDataC: mglDataC (intsize,intcols,const float *dat2) - Конструктор класса
mglDataC: mglDataC (intsize,const double *dat2) - Конструктор класса
mglDataC: mglDataC (intsize,intcols,const double *dat2) - Конструктор класса
mglDataC: mglDataC (intsize,const dual *dat2) - Конструктор класса
mglDataC: mglDataC (intsize,intcols,const dual *dat2) Копирует данные из другого экземпляра данных. Если указана формула eq, то данные заполняются также как при использовании fill.
- Команда MGL: copy REDAT IMDAT dat2
Копирует действительную и мнимую часть данных из комплексного массива данных dat2.
- Команда MGL: copy DAT 'name'
Копирует данные из другого экземпляра данных с именем name. При этом имя name может быть некорректным с точки зрения MGL (например, взятым из HDF5 файла).
- Команда MGL: read DAT 'fname'
- Конструктор класса
mglData: mglData (const char *fname) - Конструктор класса
mglDataC: mglDataC (const char *fname) - Функция С:
HMDTmgl_create_data_file (const char *fname) - Функция С:
HADTmgl_create_datac_file (const char *fname) Читает данные из текстового файла с автоматическим определением размеров массива.
- Команда MGL: delete dat
- Команда MGL: delete 'name'
- Destructor on
mglData: ~mglData () - Функция С:
voidmgl_delete_data (HMDTdat) - Destructor on
mglDataC: ~mglDataC () - Функция С:
voidmgl_delete_datac (HADTdat) Удаляет массив данных из памяти.
Next: Data filling, Previous: Data constructor, Up: Data processing [Contents][Index]
6.3 Изменение размеров данных
- Команда MGL: new DAT [
nx=1 ny=1 nz=1] - Метод класса
mglData:voidCreate (intmx,intmy=1,intmz=1) - Метод класса
mglDataC:voidCreate (intmx,intmy=1,intmz=1) - Функция С:
voidmgl_data_create (HMDTdat,intmx,intmy,intmz) - Функция С:
voidmgl_datac_create (HADTdat,intmx,intmy,intmz) Создает/пересоздает массив данных указанного размера и заполняет его нулями. Ничего не делает при mx, my, mz отрицательных или равных нулю.
- Команда MGL: rearrange dat
mx [my=0 mz=0] - Метод класса
mglData:voidRearrange (intmx,intmy=0,intmz=0) - Метод класса
mglDataC:voidRearrange (intmx,intmy=0,intmz=0) - Функция С:
voidmgl_data_rearrange (HMDTdat,intmx,intmy,intmz) - Функция С:
voidmgl_datac_rearrange (HADTdat,intmx,intmy,intmz) Изменяет размерность данных без изменения самого массива данных, так что результирующий массив mx*my*mz < nx*ny*nz. Если один из параметров my или mz ноль, то он будет выбран оптимальным образом. Например, если my=0, то будет my=nx*ny*nz/mx и mz=1.
- Команда MGL: transpose dat ['dim'='yxz']
- Метод класса
mglData:voidTranspose (const char *dim="yx") - Метод класса
mglDataC:voidTranspose (const char *dim="yx") - Функция С:
voidmgl_data_transpose (const char *dim) - Функция С:
voidmgl_datac_transpose (HADTdat,const char *dim) Транспонирует (меняет порядок размерностей) массив данных. Новый порядок размерностей задается строкой dim. Функция может быть полезна для транспонирования одномерных (или квазиодномерных) массивов после чтения их из файла.
- Команда MGL: extend dat
n1 [n2=0] - Метод класса
mglData:voidExtend (intn1,intn2=0) - Метод класса
mglDataC:voidExtend (intn1,intn2=0) - Функция С:
voidmgl_data_extend (HMDTdat,intn1,intn2) - Функция С:
voidmgl_datac_extend (HADTdat,intn1,intn2) Увеличивает размер данных путем вставки (|n1|+1) новых срезов после (для n1>0) или перед (для n1<0) существующими данными. Можно добавить сразу 2 размерности для 1d массива, используя второй параметр n2. Данные в новые срезы будут скопированы из существующих. Например, для n1>0 новый массив будет a_ij^new = a_i^old where j=0...n1. Соответственно, для n1<0 новый массив будет a_ij^new = a_j^old, где i=0...|n1|.
- Команда MGL: squeeze dat
rx [ry=1 rz=1 sm=off] - Метод класса
mglData:voidSqueeze (intrx,intry=1,intrz=1,boolsmooth=false) - Метод класса
mglDataC:voidSqueeze (intrx,intry=1,intrz=1,boolsmooth=false) - Функция С:
voidmgl_data_squeeze (HMDTdat,intrx,intry,intrz,intsmooth) - Функция С:
voidmgl_datac_squeeze (HADTdat,intrx,intry,intrz,intsmooth) Уменьшает размер данных путём удаления элементов с индексами не кратными rx, ry, rz соответственно. Параметр smooth задает использовать сглаживания (т.е. out[i]=\sum_{j=i,i+r} a[j]/r) или нет (т.е. out[i]=a[j*r]).
- Команда MGL: crop dat
n1 n2'dir' - Метод класса
mglData:voidCrop (intn1,intn2,chardir='x') - Метод класса
mglDataC:voidCrop (intn1,intn2,chardir='x') - Функция С:
voidmgl_data_crop (HMDTdat,intn1,intn2,chardir) - Функция С:
voidmgl_datac_crop (HADTdat,intn1,intn2,chardir) Обрезает границы данных при i<n1 и i>n2 (при n2>0) или i>
n[xyz]-n2 (при n2<=0) вдоль направления dir.
- Команда MGL: crop dat 'how'
- Метод класса
mglData:voidCrop (const char *how="235x") - Метод класса
mglDataC:voidCrop (const char *how="235x") - Функция Сn:
voidmgl_data_crop_opt (HMDTdat,const char *how) - Функция Сn:
voidmgl_datac_crop_opt (HADTdat,const char *how) Обрезает дальний край данных, чтобы сделать их более оптимальным для быстрого преобразования Фурье. Размер массива будет равен наиболее близким к исходному из 2^n*3^m*5^l. Строка how может содержать: ‘x’, ‘y’, ‘z’ для направлений, и ‘2’, ‘3’, ‘5’ для использования соответствующего основания.
- Команда MGL: insert dat 'dir'
[pos=off num=0] - Метод класса
mglData:voidInsert (chardir,intpos=0,intnum=1) - Метод класса
mglDataC:voidInsert (chardir,intpos=0,intnum=1) - Функция С:
voidmgl_data_insert (HMDTdat,chardir,intpos,charnum) - Функция С:
voidmgl_datac_insert (HADTdat,chardir,intpos,charnum) Вставляет num срезов вдоль направления dir с позиции pos и заполняет их нулями.
- Команда MGL: delete dat 'dir'
[pos=off num=0] - Метод класса
mglData:voidDelete (chardir,intpos=0,intnum=1) - Метод класса
mglDataC:voidDelete (chardir,intpos=0,intnum=1) - Функция С:
voidmgl_data_delete (HMDTdat,chardir,intpos,charnum) - Функция С:
voidmgl_datac_delete (HADTdat,chardir,intpos,charnum) Удаляет num срезов вдоль направления dir с позиции pos.
- Команда MGL: sort dat
idx [idy=-1] - Метод класса
mglData:voidSort (londidx,longidy=-1) - Функция С:
voidmgl_data_sort (HMDTdat,londidx,longidy) Сортирует строки (или срезы в 3D случае) по значениям в указанной колонке idx (или ячейках {idx,idy} для 3D случая). Не используйте в многопоточных функциях!
- Команда MGL: clean dat
idx - Метод класса
mglData:voidClean (londidx) - Функция С:
voidmgl_data_clean (HMDTdat,londidx) Удаляет строки в которых значения для заданной колонки idx совпадают со значениями в следующей строке.
- Команда MGL: join dat vdat [v2dat ...]
- Метод класса
mglData:voidJoin (const mglDataA &vdat) - Метод класса
mglDataC:voidJoin (const mglDataA &vdat) - Функция С:
voidmgl_data_join (HMDTdat,HCDTvdat) - Функция С:
voidmgl_datac_join (HADTdat,HCDTvdat) Объединяет данные из массива vdat с данными массива dat. При этом, функция увеличивает размер массива dat: в z-направлении для массивов с одинаковыми размерами по x и y; в y-направлении для массивов с одинаковыми размерами по x; в x-направлении в остальных случаях.
Next: File I/O, Previous: Data resizing, Up: Data processing [Contents][Index]
6.4 Заполнение данных
- Команда MGL: list DAT
v1 ... Создает новый массив данных dat и заполняет его числовыми значениями аргументов
v1 .... Команда может создавать одно- и двухмерные массивы с произвольными значениями. Для создания 2d массива следует использовать разделитель ‘|’, который означает начало новой строки данных. Размер массива данных будет [maximal of row sizes * number of rows]. Например, командаlist 1 | 2 3создаст массив [1 0; 2 3]. Замечу, что максимальное число аргументов равно 1000.
- Команда MGL: list DAT d1 ...
Создает новый массив данных dat и заполняет его значениями из массивов d1 .... Команда может создавать двух- и трёхмерные (если аргументы – двумерные массивы) массивы. Меньшая размерность всех массивов в аргументах должна совпадать. В противном случае аргумент (массив) будет пропущен.
- Метод класса
mglData:voidSet (const mreal *A,intNX,intNY=1,intNZ=1) - Метод класса
mglData:voidSet (const double *A,intNX,intNY=1,intNZ=1) - Функция С:
voidmgl_data_set_mreal (HMDTdat,const mreal *A,intNX,intNY,intNZ) - Функция С:
voidmgl_data_set_double (HMDTdat,const double *A,intNX,intNY,intNZ) - Метод класса
mglDataC:voidSet (const float *A,intNX,intNY=1,intNZ=1) - Метод класса
mglDataC:voidSet (const double *A,intNX,intNY=1,intNZ=1) - Метод класса
mglDataC:voidSet (const dual *A,intNX,intNY=1,intNZ=1) - Функция С:
voidmgl_datac_set_float (HADTdat,const mreal *A,intNX,intNY,intNZ) - Функция С:
voidmgl_datac_set_double (HADTdat,const double *A,intNX,intNY,intNZ) - Функция С:
voidmgl_datac_set_complex (HADTdat,const dual *A,intNX,intNY,intNZ) Выделяет память и копирует данные из массивов типа
mreal*илиdouble*, т.е. из массивов определённых какmreal a[NX*NY*NZ];.
- Метод класса
mglData:voidSet (const mreal **A,intN1,intN2) - Метод класса
mglData:voidSet (const double **A,intN1,intN2) - Функция С:
voidmgl_data_set_mreal2 (HMDTdat,const mreal **A,intN1,intN2) - Функция С:
voidmgl_data_set_double2 (HMDTdat,const double **A,intN1,intN2) Выделяет память и копирует данные из массивов типа
mreal**илиdouble**с размерностями N1, N2, т.е. из массивов определённых какmreal a[N1][N2];.
- Метод класса
mglData:voidSet (const mreal ***A,intN1,intN2) - Метод класса
mglData:voidSet (const double ***A,intN1,intN2) - Функция С:
voidmgl_data_set_mreal3 (HMDTdat,const mreal ***A,intN1,intN2) - Функция С:
voidmgl_data_set_double3 (HMDTdat,const double ***A,intN1,intN2) Выделяет память и копирует данные из массивов типа
mreal***илиdouble***с размерностями N1, N2, N3, т.е. из массивов определённых какmreal a[N1][N2][N3];.
- Метод класса
mglData:voidSet (gsl_vector *v) - Метод класса
mglDataC:voidSet (gsl_vector *v) - Функция С:
voidmgl_data_set_vector (HMDTdat,gsl_vector *v) - Функция С:
voidmgl_datac_set_vector (HADTdat,gsl_vector *v) Выделяет память и копирует данные из структуры типа
gsl_vector *.
- Метод класса
mglData:voidSet (gsl_matrix *m) - Метод класса
mglDataC:voidSet (gsl_matrix *m) - Функция С:
voidmgl_data_set_matrix (HMDTdat,gsl_matrix *m) - Функция С:
voidmgl_datac_set_matrix (HADTdat,gsl_matrix *m) Выделяет память и копирует данные из структуры типа
gsl_matrix *.
- Метод класса
mglData:voidSet (const mglDataA &from) - Метод класса
mglData:voidSet (HCDTfrom) - Функция С:
voidmgl_data_set (HMDTdat,HCDTfrom) - Метод класса
mglDataC:voidSet (const mglDataA &from) - Метод класса
mglDataC:voidSet (HCDTfrom) - Функция С:
voidmgl_datac_set (HADTdat,HCDTfrom) Выделяет память и копирует данные из другого экземпляра данных from.
- Метод класса
mglDataC:voidSet (const mglDataA &re,const mglDataA &im) - Метод класса
mglDataC:voidSet (HCDTre,HCDTim) - Метод класса
mglDataC:voidSetAmpl (HCDTampl,const mglDataA &phase) - Функция С:
voidmgl_datac_set_ri (HADTdat,HCDTre,HCDTim) - Функция С:
voidmgl_datac_set_ap (HADTdat,HCDTampl,HCDTphase) Выделяет память и копирует данные из экземпляра данных для действительной re и мнимой im частей комплексного массива данных.
- Метод класса
mglData:voidSet (const std::vector<int> &d) - Метод класса
mglDataC:voidSet (const std::vector<int> &d) - Метод класса
mglData:voidSet (const std::vector<float> &d) - Метод класса
mglDataC:voidSet (const std::vector<float> &d) - Метод класса
mglData:voidSet (const std::vector<double> &d) - Метод класса
mglDataC:voidSet (const std::vector<double> &d) - Метод класса
mglDataC:voidSet (const std::vector<dual> &d) Выделяет память и копирует данные из массива типа
std::vector<T>.
- Метод класса
mglData:voidSet (const char *str,intNX,intNY=1,intNZ=1) - Функция С:
voidmgl_data_set_values (const char *str,intNX,intNY,intNZ) - Метод класса
mglDataC:voidSet (const char *str,intNX,intNY=1,intNZ=1) - Функция С:
voidmgl_datac_set_values (const char *str,intNX,intNY,intNZ) Выделяет память и сканирует массив данных из строки.
- Метод класса
mglData:voidSetList (longn, ...) Allocate memory and set data from variable argument list of double values. Note, you need to specify decimal point ‘.’ for integer values! For example, the code
SetList(2,0.,1.);is correct, but the codeSetList(2,0,1);is incorrect.
- Метод класса
mglData:voidLink (mglData &from) - Метод класса
mglData:voidLink (mreal *A,intNX,intNY=1,intNZ=1) - Функция С:
voidmgl_data_link (HMDTdat,const mreal *A,intNX,intNY,intNZ) - Метод класса
mglDataC:voidLink (mglDataC &from) - Метод класса
mglDataC:voidLink (dual *A,intNX,intNY=1,intNZ=1) - Функция С:
voidmgl_datac_link (HADTdat,const mreal *A,intNX,intNY,intNZ) Устанавливает флаг использования внешнего массива данных, которые не будут удалены. Флаг может быть возвращён в исходное состояние и создан новый внутренний массив если использовались функции изменяющие размер данных.
- Команда MGL: var DAT
num v1 [v2=nan] Создает новый одномерный массив данных dat размером num, и заполняет его равномерно в диапазоне [v1, v2]. Если v2=
nan, то используется v2=v1.
- Команда MGL: fill dat v1 v2 ['dir'='x']
- Метод класса
mglData:voidFill (mrealv1,mrealv2,chardir='x') - Метод класса
mglDataC:voidFill (dualv1,dualv2,chardir='x') - Функция С:
voidmgl_data_fill (HMDTdat,mrealv1,mrealv2,chardir) - Функция С:
voidmgl_datac_fill (HADTdat,dualv1,dualv2,chardir) Заполняет значениями равно распределёнными в диапазоне [x1, x2] в направлении dir={‘x’,‘y’,‘z’}.
- Команда MGL: fill dat 'eq'[vdat wdat]
- Метод класса
mglData:voidFill (HMGLgr,const char *eq,const char *opt="") - Метод класса
mglData:voidFill (HMGLgr,const char *eq,const mglDataA &vdat,const char *opt="") - Метод класса
mglData:voidFill (HMGLgr,const char *eq,const mglDataA &vdat,const mglDataA &wdat,const char *opt="") - Метод класса
mglDataC:voidFill (HMGLgr,const char *eq,const char *opt="") - Метод класса
mglDataC:voidFill (HMGLgr,const char *eq,const mglDataA &vdat,const char *opt="") - Метод класса
mglDataC:voidFill (HMGLgr,const char *eq,const mglDataA &vdat,const mglDataA &wdat,const char *opt="") - Функция С:
voidmgl_data_fill_eq (HMGLgr,HMDTdat,const char *eq,HCDTvdat,HCDTwdat,const char *opt) - Функция С:
voidmgl_datac_fill_eq (HMGLgr,HADTdat,const char *eq,HCDTvdat,HCDTwdat,const char *opt) Заполняет значениями вычисленными по формуле eq. Формула представляет собой произвольное выражение, зависящее от переменных ‘x’, ‘y’, ‘z’, ‘u’, ‘v’, ‘w’. Координаты ‘x’, ‘y’, ‘z’ полагаются меняющимися в диапазоне Min x Max (в отличие от функции
Modify). Переменная ‘u’ – значения исходного массива, переменные ‘v’, ‘w’ – значения массивов vdat, wdat. Последние могут бытьNULL, т.е. опущены.
- Команда MGL: modify dat 'eq' [
dim=0] - Команда MGL: modify dat 'eq' vdat [wdat]
- Метод класса
mglData:voidModify (const char *eq,intdim=0) - Метод класса
mglData:voidModify (const char *eq,const mglDataA &v) - Метод класса
mglData:voidModify (const char *eq,const mglDataA &v,const mglDataA &w) - Метод класса
mglDataC:voidModify (const char *eq,intdim=0) - Метод класса
mglDataC:voidModify (const char *eq,const mglDataA &v) - Метод класса
mglDataC:voidModify (const char *eq,const mglDataA &v,const mglDataA &w) - Функция С:
voidmgl_data_modify (HMDTdat,const char *eq,intdim) - Функция С:
voidmgl_data_modify_vw (HMDTdat,const char *eq,HCDTv,HCDTw) - Функция С:
voidmgl_datac_modify (HADTdat,const char *eq,intdim) - Функция С:
voidmgl_datac_modify_vw (HADTdat,const char *eq,HCDTv,HCDTw) Аналогично предыдущему с координатами ‘x’, ‘y’, ‘z’, меняющимися в диапазоне [0,1]. Если указан dim>0, то изменяются только слои >=dim.
- Команда MGL: fillsample dat 'how'
- Метод класса
mglData:voidFillSample (const char *how) - Функция С:
voidmgl_data_fill_sample (HMDTa,const char *how) Заполняет массив данных ’x’ или ’k’ значениями для преобразований Ханкеля (’h’) или Фурье (’f’).
- Команда MGL: datagrid dat xdat ydat zdat
- Метод класса
mglData:mglDataGrid (HMGLgr,const mglDataA &x,const mglDataA &y,const mglDataA &z,const char *opt="") - Метод класса
mglData:mglDataGrid (const mglDataA &x,const mglDataA &y,const mglDataA &z,mglPointp1,mglPointp2) - Функция С:
voidmgl_data_grid (HMGLgr,HMDTu,HCDTx,HCDTy,HCDTz,const char *opt) - Функция С:
voidmgl_data_grid_xy (HMDTu,HCDTx,HCDTy,HCDTz,mrealx1,mrealx2,mrealy1,mrealy2) Заполняет значения массива результатом линейной интерполяции (считая координаты равнораспределенными в диапазоне осей координат или в диапазоне [x1,x2]*[y1,y2]) по триангулированной поверхности, найденной по произвольно расположенным точкам ‘x’, ‘y’, ‘z’. NAN значение используется для точек сетки вне триангулированной поверхности. См. раздел Making regular data, для примеров кода и графика.
- Команда MGL: put dat
val [i=all j=all k=all] - Метод класса
mglData:voidPut (mrealval,inti=-1,intj=-1,intk=-1) - Метод класса
mglDataC:voidPut (dualval,inti=-1,intj=-1,intk=-1) - Функция С:
voidmgl_data_put_val (HMDTa,mrealval,inti,intj,intk) - Функция С:
voidmgl_datac_put_val (HADTa,dualval,inti,intj,intk) Присваивает значения (под-)массива dat[i, j, k] = val. Индексы i, j, k равные ‘-1’ задают значения val для всего диапазона соответствующего направления(ий). Например,
Put(val,-1,0,-1);задает a[i,0,j]=val для i=0...(nx-1), j=0...(nz-1).
- Команда MGL: put dat vdat [
i=all j=all k=all] - Метод класса
mglData:voidPut (const mglDataA &v,inti=-1,intj=-1,intk=-1) - Метод класса
mglDataC:voidPut (const mglDataA &v,inti=-1,intj=-1,intk=-1) - Функция С:
voidmgl_data_put_dat (HMDTa,HCDTv,inti,intj,intk) - Функция С:
voidmgl_datac_put_dat (HADTa,HCDTv,inti,intj,intk) Копирует значения из массива v в диапазон значений данного массива. Индексы i, j, k равные ‘-1’ задают диапазон изменения значений в соответствующих направление(ях). Младшие размерности массива v должны быть больше выбранного диапазона массива. Например,
Put(v,-1,0,-1);присвоит a[i,0,j]=v.ny>nz ? v.a[i,j] : v.a[i], где i=0...(nx-1), j=0...(nz-1) и условие v.nx>=nx выполнено.
- Команда MGL: refill dat xdat vdat [sl=-1]
- Команда MGL: refill dat xdat ydat vdat [sl=-1]
- Команда MGL: refill dat xdat ydat zdat vdat
- Метод класса
mglData:voidRefill (const mglDataA &x,const mglDataA &v,mrealx1,mrealx2,longsl=-1) - Метод класса
mglData:voidRefill (const mglDataA &x,const mglDataA &v,mglPointp1,mglPointp2,longsl=-1) - Метод класса
mglData:voidRefill (const mglDataA &x,const mglDataA &y,const mglDataA &v,mglPointp1,mglPointp2,longsl=-1) - Метод класса
mglData:voidRefill (const mglDataA &x,const mglDataA &y,const mglDataA &z,const mglDataA &v,mglPointp1,mglPointp2) - Метод класса
mglData:voidRefill (HMGLgr,const mglDataA &x,const mglDataA &v,longsl=-1,const char *opt="") - Метод класса
mglData:voidRefill (HMGLgr,const mglDataA &x,const mglDataA &y,const mglDataA &v,longsl=-1,const char *opt="") - Метод класса
mglData:voidRefill (HMGLgr,const mglDataA &x,const mglDataA &y,const mglDataA &z,const mglDataA &v,const char *opt="") - Функция С:
voidmgl_data_refill_x (HMDTa,HCDTx,HCDTv,mrealx1,mrealx2,longsl) - Функция С:
voidmgl_data_refill_xy (HMDTa,HCDTx,HCDTy,HCDTv,mrealx1,mrealx2,mrealy1,mrealy2,longsl) - Функция С:
voidmgl_data_refill_xyz (HMDTa,HCDTx,HCDTy,HCDTz,HCDTv,mrealx1,mrealx2,mrealy1,mrealy2,mrealz1,mrealz2) - Функция С:
voidmgl_data_refill_gr (HMGLgr,HMDTa,HCDTx,HCDTy,HCDTz,HCDTv,longsl,const char *opt) Заполняет значениями интерполяции массива v в точках {x, y, z}={
X[i], Y[j], Z[k]} (или {x, y, z}={X[i,j,k], Y[i,j,k], Z[i,j,k]} если x, y, z не 1d массивы), гдеX,Y,Zравномерно распределены в диапазоне [x1,x2]*[y1,y2]*[z1,z2] и имеют такой же размер как и заполняемый массив. Если параметр sl равен 0 или положительный, то изменятся будет только sl-ый срез.
- Команда MGL: gspline dat xdat vdat [sl=-1]
- Метод класса
mglData:voidRefillGS (const mglDataA &x,const mglDataA &v,mrealx1,mrealx2,longsl=-1) - Функция С:
voidmgl_data_refill_gs (HMDTa,HCDTx,HCDTv,mrealx1,mrealx2,longsl) Заполняет значениями глобального кубического сплайна для массива v в точках x=
X[i], гдеXравномерно распределен в диапазоне [x1,x2] и имеет такой же размер как и заполняемый массив. Если параметр sl равен 0 или положительный, то изменятся будет только sl-ый срез.
- Команда MGL: idset dat 'ids'
- Метод класса
mglData:voidSetColumnId (const char *ids) - Функция С:
voidmgl_data_set_id (const char *ids) - Метод класса
mglDataC:voidSetColumnId (const char *ids) - Функция С:
voidmgl_datac_set_id (HADTa,const char *ids) Задает названия ids для колонок массива данных. Строка должна содержать один символ ’a’...’z’ на колонку. Эти названия используются в функции column.
Next: Make another data, Previous: Data filling, Up: Data processing [Contents][Index]
6.5 Чтение/сохранение данных
- Команда MGL: read DAT 'fname'
- Команда MGL: read REDAT IMDAT 'fname'
- Метод класса
mglData:voidRead (const char *fname) - Метод класса
mglDataC:boolRead (const char *fname) - Функция С:
intmgl_data_read (HMDTdat,const char *fname) - Функция С:
intmgl_datac_read (HADTdat,const char *fname) Читает данные из текстового файла с разделителями символом пробела/табуляции с автоматическим определением размера массива. Двойной перевод строки начинает новый срез данных (по направлению z).
- Команда MGL: read DAT 'fname'
mx [my=1 mz=1] - Команда MGL: read REDAT IMDAT 'fname'
mx [my=1 mz=1] - Метод класса
mglData:voidRead (const char *fname,intmx,intmy=1,intmz=1) - Метод класса
mglDataC:boolRead (const char *fname,intmx,intmy=1,intmz=1) - Функция С:
intmgl_data_read_dim (HMDTdat,const char *fname,intmx,intmy,intmz) - Функция С:
intmgl_datac_read_dim (HADTdat,const char *fname,intmx,intmy,intmz) Читает данные из текстового файла с заданными размерами. Ничего не делается если параметры mx, my или mz равны нулю или отрицательны.
- Команда MGL: readmat DAT 'fname' [
dim=2] - Метод класса
mglData:voidReadMat (const char *fname,intdim=2) - Метод класса
mglDataC:boolReadMat (const char *fname,intdim=2) - Функция С:
intmgl_data_read_mat (HMDTdat,const char *fname,intdim) - Функция С:
intmgl_datac_read_mat (HADTdat,const char *fname,intdim) Читает данные из текстового файла с размерами, указанными в первых dim числах файла. При этом переменная dim задает размерность (1d, 2d, 3d) данных.
- Команда MGL: readall DAT 'templ'
v1 v2 [dv=1 slice=off] - Метод класса
mglData:voidReadRange (const char *templ,mrealfrom,mrealto,mrealstep=1.f,boolas_slice=false) - Метод класса
mglDataC:voidReadRange (const char *templ,mrealfrom,mrealto,mrealstep=1,boolas_slice=false) - Функция С:
intmgl_data_read_range (HMDTdat,const char *templ,mrealfrom,mrealto,mrealstep,intas_slice) - Функция С:
intmgl_datac_read_range (HADTdat,const char *templ,mrealfrom,mrealto,mrealstep,intas_slice) Объединяет данные из нескольких текстовых файлов. Имена файлов определяются вызовом функции
sprintf(fname,templ,val);, где val меняется от from до to с шагом step. Данные загружаются один за другим в один и тот же срез данных (при as_slice=false) или срез-за-срезом (при as_slice=true).
- Команда MGL: readall DAT 'templ'
[slice=off] - Метод класса
mglData:voidReadAll (const char *templ,boolas_slice=false) - Метод класса
mglDataC:voidReadAll (const char *templ,boolas_slice=false) - Функция С:
intmgl_data_read_all (HMDTdat,const char *templ,intas_slice) - Функция С:
intmgl_datac_read_all (HADTdat,const char *templ,intas_slice) Объединяет данные из нескольких текстовых файлов, чьи имена удовлетворяют шаблону templ (например, templ=
"t_*.dat"). Данные загружаются один за другим в один и тот же срез данных (при as_slice=false) или срез-за-срезом (при as_slice=true).
- Команда MGL: scanfile DAT 'fname' 'templ'
- Метод класса
mglData:boolScanFile (const char *fname,const char *templ) - Функция С:
intmgl_data_scan_file (HMDTdat,const char *fname,const char *templ) Читает файл fname построчно и каждую строку сканирует на соответствие шаблону templ. Полученные числа (обозначаются как ‘%g’ в шаблоне) сохраняются. См. раздел Saving and scanning file, для примеров кода и графика.
- Команда MGL: save dat 'fname'
- Метод класса
mglDataA:voidSave (const char *fname,intns=-1)const - Функция С:
voidmgl_data_save (HCDTdat,const char *fname,intns) - Функция С:
voidmgl_datac_save (HCDTdat,const char *fname,intns) Сохраняет весь массив данных при ns=
-1или только ns-ый срез в текстовый файл.
- Команда MGL: save 'str' 'fname' ['mode'='a']
Сохраняет строку str в файл fname. Для параметра mode=‘a’ происходит добавление строки (по умолчанию): для mode=‘w’ файл будет перезаписан. См. раздел Saving and scanning file, для примеров кода и графика.
- Команда MGL: readhdf DAT 'fname' 'dname'
- Метод класса
mglData:voidReadHDF (const char *fname,const char *dname) - Метод класса
mglDataC:voidReadHDF (const char *fname,const char *dname) - Функция С:
voidmgl_data_read_hdf (HMDTdat,const char *fname,const char *dname) - Функция С:
voidmgl_datac_read_hdf (HADTdat,const char *fname,const char *dname) Читает массив с именем dname из HDF5 или HDF4 файла fname. Функция ничего не делает если библиотека была собрана без поддержки HDF5|HDF4.
- Команда MGL: savehdf dat 'fname' 'dname' [
rewrite=off] - Метод класса
mglDataA:voidSaveHDF (const char *fname,const char *dname,boolrewrite=false)const - Функция С:
voidmgl_data_save_hdf (HCDTdat,const char *fname,const char *dname,intrewrite) - Функция С:
voidmgl_datac_save_hdf (HCDTdat,const char *fname,const char *dname,intrewrite) Сохраняет массив под именем dname в HDF5 или HDF4 файл fname. Функция ничего не делает если библиотека была собрана без поддержки HDF5|HDF4.
- Команда MGL: datas 'fname'
- Метод класса
mglDataA:intDatasHDF (const char *fname,char *buf,longsize)static - Функция С:
voidmgl_datas_hdf (const char *fname,char *buf,longsize) Помещает имена массивов данных в HDF5 файле fname в строку buf разделёнными символом табуляции ’\t’. В версии MGL имена массивов будут выведены как сообщение. Функция ничего не делает если библиотека была собрана без поддержки HDF5.
- Команда MGL: openhdf 'fname'
- Метод класса
mglParse:voidOpenHDF (const char *fname) - Функция С:
voidmgl_parser_openhdf (HMPRpr,const char *fname) Читает все массивы данных из HDF5 файла fname и создает переменные MGL с соответствующими именами. Если имя данных начинается с ‘!’, то будут созданы комплексные массивы.
- Функция С:
const char * const *mgl_datas_hdf_str (HMPRpr,const char *fname) Помещает имена данных из HDF файла fname в массив строк (последняя строка ""). Массив строк будет изменен при следующем вызове функции.
- Команда MGL: import DAT 'fname' 'sch' [
v1=0 v2=1] - Метод класса
mglData:voidImport (const char *fname,const char *scheme,mrealv1=0, mreal v2=1) - Функция С:
voidmgl_data_import (HMDTdat,const char *fname,const char *scheme,mrealv1, mreal v2) Читает данные из растрового файла. RGB значения пикселов преобразуются в число в диапазоне [v1, v2] используя цветовую схему sch (see Color scheme).
- Команда MGL: export dat 'fname' 'sch' [
v1=0 v2=0] - Метод класса
mglDataA:voidExport (const char *fname,const char *scheme,mrealv1=0, mreal v2=0,intns=-1) const - Функция С:
voidmgl_data_export (HMDTdat,const char *fname,const char *scheme,mrealv1, mreal v2,intns) const Сохраняет данные в растровый файл. Числовые значения, нормированные в диапазон [v1, v2], преобразуются в RGB значения пикселов, используя цветовую схему sch (see Color scheme). Если v1>=v2, то значения v1, v2 определяются автоматически как минимальное и максимальное значение данных.
Next: Data changing, Previous: File I/O, Up: Data processing [Contents][Index]
6.6 Make another data
- Команда MGL: subdata RES dat
xx [yy=all zz=all] - Метод класса
mglData:mglDataSubData (mrealxx,mrealyy=-1,mrealzz=-1)const - Метод класса
mglDataC:mglDataSubData (mrealxx,mrealyy=-1,mrealzz=-1)const - Функция С:
HMDTmgl_data_subdata (HCDTdat,mrealxx,mrealyy,mrealzz) Возвращает в res подмассив массива данных dat с фиксированными значениями индексов с положительными значениями. Например,
SubData(-1,2)выделяет третью строку (индексы начинаются с нуля),SubData(4,-1)выделяет 5-ую колонку,SubData(-1,-1,3)выделяет 4-ый срез и т.д. В MGL скриптах обычно используется упрощенная версияdat(xx,yy,zz). Функция возвращает NULL или пустой массив если данные не могут быть созданы при данных значениях аргументов.
- Команда MGL: subdata RES dat xdat [ydat zdat]
- Метод класса
mglData:mglDataSubData (const mglDataA &xx,const mglDataA &yy,const mglDataA &zz)const - Метод класса
mglDataC:mglDataSubData (const mglDataA &xx,const mglDataA &yy,const mglDataA &zz)const - Функция С:
HMDTmgl_data_subdata_ext (HCDTdat,HCDTxx,HCDTyy,HCDTzz) Возвращает в res подмассив массива данных dat с индексами, заданными в массивах xx, yy, zz (косвенная адресация). Результат будет иметь размерность массивов с индексами. Размеры массивов xx, yy, zz с индексами должна быть одинакова, либо должны быть "скаляром" (т.е. 1*1*1). В MGL скриптах обычно используется упрощенная версия
dat(xx,yy,zz). Функция возвращает NULL или пустой массив если данные не могут быть созданы при данных значениях аргументов.
- Команда MGL: column RES dat 'eq'
- Метод класса
mglData:mglDataColumn (const char *eq)const - Метод класса
mglDataC:mglDataColumn (const char *eq)const - Функция С:
HMDTmgl_data_column (HCDTdat,const char *eq) Возвращает массив данных заполненный по формуле eq, вычисленной для именованных колонок (или срезов). Например,
Column("n*w^2/exp(t)");. Имена колонок должны быть предварительно заданы функцией idset или при чтении файлов данных. В MGL скриптах обычно используется упрощенная версияdat('eq'). Функция возвращает NULL или пустой массив если данные не могут быть созданы при данных значениях аргументов.
- Команда MGL: resize RES dat
mx [my=1 mz=1] - Метод класса
mglData:mglDataResize (intmx,intmy=0,intmz=0,mrealx1=0,mrealx2=1,mrealy1=0,mrealy2=1,mrealz1=0,mrealz2=1)const - Метод класса
mglDataC:mglDataResize (intmx,intmy=0,intmz=0,mrealx1=0,mrealx2=1,mrealy1=0,mrealy2=1,mrealz1=0,mrealz2=1)const - Функция С:
HMDTmgl_data_resize (HCDTdat,intmx,intmy,intmz) - Функция С:
HMDTmgl_data_resize_box (HCDTdat,intmx,intmy,intmz,mrealx1,mrealx2,mrealy1,mrealy2,mrealz1,mrealz2) Возвращает массив данных размером mx, my, mz со значениями полученными интерполяцией значений из части [x1,x2] x [y1,y2] x [z1,z2] исходного массива. Величины x,y,z полагаются нормированными в диапазоне [0,1]. Если значение mx, my или mz равно 0, то исходный размер используется. Функция возвращает NULL или пустой массив если данные не могут быть созданы при данных значениях аргументов.
- Команда MGL: evaluate RES dat idat [
norm=on] - Команда MGL: evaluate RES dat idat jdat [
norm=on] - Команда MGL: evaluate RES dat idat jdat kdat [
norm=on] - Метод класса
mglData:mglDataEvaluate (const mglDataA &idat,boolnorm=true)const - Метод класса
mglData:mglDataEvaluate (const mglDataA &idat,const mglDataA &jdat,boolnorm=true)const - Метод класса
mglData:mglDataEvaluate (const mglDataA &idat,const mglDataA &jdat,const mglDataA &kdat,boolnorm=true)const - Метод класса
mglDataC:mglDataEvaluate (const mglDataA &idat,boolnorm=true)const - Метод класса
mglDataC:mglDataEvaluate (const mglDataA &idat,const mglDataA &jdat,boolnorm=true)const - Метод класса
mglDataC:mglDataEvaluate (const mglDataA &idat,const mglDataA &jdat,const mglDataA &kdat,boolnorm=true)const - Функция С:
HMDTmgl_data_evaluate (HCDTdat,HCDTidat,HCDTjdat,HCDTkdat,intnorm) Возвращает массив данных, полученный в результате интерполяции исходного массива в точках других массивов (например, res[i,j]=dat[idat[i,j],jdat[i,j]]). Размеры массивов idat, jdat, kdat должны совпадать. Координаты в idat, jdat, kdat полагаются нормированными в диапазон [0,1] (при norm=
true) или в диапазоны [0,nx], [0,ny], [0,nz] соответственно. Функция возвращает NULL или пустой массив если данные не могут быть созданы при данных значениях аргументов.
- Команда MGL: section RES dat ids ['dir'='y'
val=nan] - Команда MGL: section RES dat
id['dir'='y'val=nan] - Метод класса
mglData:mglDataSection (const mglDataA &ids,const char *dir='y',mrealval=NAN)const - Метод класса
mglData:mglDataSection (longid,const char *dir='y',mrealval=NAN)const - Метод класса
mglDataC:mglDataSection (const mglDataA &ids,const char *dir='y',mrealval=NAN)const - Метод класса
mglDataC:mglDataSection (longid,const char *dir='y',mrealval=NAN)const - Функция С:
HMDTmgl_data_section (HCDTdat,HCDTids,const char *dir,mrealval) - Функция С:
HMDTmgl_data_section_val (HCDTdat,longid,const char *dir,mrealval) - Функция С:
HADTmgl_datac_section (HCDTdat,HCDTids,const char *dir,mrealval) - Функция С:
HADTmgl_datac_section_val (HCDTdat,longid,const char *dir,mrealval) Возвращает массив данных, являющийся id-ой секцией (диапазоном срезов, разделенных значениями val) исходного массива dat. Для id<0 используется обратный порядок (т.e. -1 даст последнюю секцию). Если указано несколько ids, то выходной массив будет результатом последовательного объединения секций.
- Команда MGL: solve RES dat
val'dir' [norm=on] - Команда MGL: solve RES dat
val'dir' idat [norm=on] - Метод класса
mglData:mglDataSolve (mrealval,chardir,boolnorm=true)const - Метод класса
mglData:mglDataSolve (mrealval,chardir,const mglDataA &idat,boolnorm=true)const - Функция С:
HMDTmgl_data_solve (HCDTdat,mrealval,chardir,HCDTidat,intnorm) Возвращает массив индексов (корней) вдоль выбранного направления dir в которых значения массива dat равны val. Выходной массив будет иметь размеры массива dat в направлениях поперечных dir. Если предоставлен массив idat, то его значения используются как стартовые при поиске. Это позволяет найти несколько веток с помощью последовательного вызова функции. Индексы полагаются нормированными в диапазон [0,1] (при norm=
true) или в диапазоны [0,nx], [0,ny], [0,nz] соответственно. Функция возвращает NULL или пустой массив если данные не могут быть созданы при данных значениях аргументов. См. раздел Solve sample, для примеров кода и графика.
- Команда MGL: roots RES 'func' ini ['var'='x']
- Команда MGL: roots RES 'func'
ini['var'='x'] - Метод класса
mglData:mglDataRoots (const char *func,charvar)const - Функция С:
HMDTmgl_data_roots (const char *func,HCDTini,charvar) - Функция С:
mrealmgl_find_root_txt (const char *func,mrealini,charvar) Возвращает массив корней уравнения ’func’=0 для переменной var с начальными положениями ini. Функция возвращает NULL или пустой массив если данные не могут быть созданы при данных значениях аргументов.
- Команда MGL: roots RES 'funcs' 'vars' ini
- Метод класса
mglData:mglDataMultiRoots (const char *funcs,const char *vars)const - Метод класса
mglDataC:mglDataCMultiRoots (const char *funcs,const char *vars)const - Функция С:
HMDTmgl_find_roots_txt (const char *func,const char *vars,HCDTini) - Функция С:
HADTmgl_find_roots_txt_c (const char *func,const char *vars,HCDTini) Возвращает массив корней системы уравнений ’funcs’=0 для переменных vars с начальными значениями ini. Функция возвращает NULL или пустой массив если данные не могут быть созданы при данных значениях аргументов.
- Команда MGL: detect RES dat
lvl dj [di=0 minlen=0] - Метод класса
mglData:mglDataDetect (mreallvl,mrealdj,mrealdi=0,mrealminlen=0)const - Функция С:
HMDTmgl_data_detect (HCDTdat,mreallvl,mrealdj,mrealdi,mrealminlen) Возвращает массив кривых {x,y}, разделенных NAN значениями, для локальных максимумов массива dat как функцию координаты x. Шумы амплитудой меньше lvl игнорируются. Параметр dj (в диапазоне [0,ny]) задает область "притяжения" точек в y-направлении к кривой. Аналогично, di продолжает кривые в x-направлении через разрывы длиной менее di точек. Кривые с минимальной длинной менее minlen игнорируются.
- Команда MGL: hist RES dat
num v1 v2 [nsub=0] - Команда MGL: hist RES dat wdat
num v1 v2 [nsub=0] - Метод класса
mglData:mglDataHist (intn,mrealv1=0,mrealv2=1,intnsub=0)const - Метод класса
mglData:mglDataHist (const mglDataA &w,intn,mrealv1=0,mrealv2=1,intnsub=0)const - Метод класса
mglDataC:mglDataHist (intn,mrealv1=0,mrealv2=1,intnsub=0)const - Метод класса
mglDataC:mglDataHist (const mglDataA &w,intn,mrealv1=0,mrealv2=1,intnsub=0)const - Функция С:
HMDTmgl_data_hist (HCDTdat,intn,mrealv1,mrealv2,intnsub) - Функция С:
HMDTmgl_data_hist_w (HCDTdat,HCDTw,intn,mrealv1,mrealv2,intnsub) Возвращает распределение (гистограмму) из n точек от значений массива в диапазоне [v1, v2]. Массив w задает веса элементов (по умолчанию все веса равны 1). Параметр nsub задает число дополнительных точек интерполяции (для сглаживания получившейся гистограммы). Функция возвращает NULL или пустой массив если данные не могут быть созданы при данных значениях аргументов. См. также Data manipulation
- Команда MGL: momentum RES dat 'how' ['dir'='z']
- Метод класса
mglData:mglDataMomentum (chardir,const char *how)const - Метод класса
mglDataC:mglDataMomentum (chardir,const char *how)const - Функция С:
HMDTmgl_data_momentum (HCDTdat,chardir,const char *how) Возвращает момент (1d массив) данных вдоль направления dir. Строка how определяет тип момента. Момент определяется как res_k = \sum_ij how(x_i,y_j,z_k) a_ij/ \sum_ij a_ij если dir=‘z’ и т.д. Координаты ‘x’, ‘y’, ‘z’ – индексы массива в диапазоне [0,1]. Функция возвращает NULL или пустой массив если данные не могут быть созданы при данных значениях аргументов.
- Команда MGL: sum RES dat 'dir'
- Метод класса
mglData:mglDataSum (const char *dir)const - Метод класса
mglDataC:mglDataSum (const char *dir)const - Функция С:
HMDTmgl_data_sum (HCDTdat,const char *dir) Возвращает результат суммирования данных вдоль направления(ий) dir. Функция возвращает NULL или пустой массив если данные не могут быть созданы при данных значениях аргументов.
- Команда MGL: max RES dat 'dir'
- Метод класса
mglData:mglDataMax (const char *dir)const - Метод класса
mglDataC:mglDataMax (const char *dir)const - Функция С:
HMDTmgl_data_max_dir (HCDTdat,const char *dir) Возвращает максимальное значение данных вдоль направления(ий) dir. Функция возвращает NULL или пустой массив если данные не могут быть созданы при данных значениях аргументов.
- Команда MGL: min RES dat 'dir'
- Метод класса
mglData:mglDataMin (const char *dir)const - Метод класса
mglDataC:mglDataMin (const char *dir)const - Функция С:
HMDTmgl_data_min_dir (HCDTdat,const char *dir) Возвращает минимальное значение данных вдоль направления(ий) dir. Функция возвращает NULL или пустой массив если данные не могут быть созданы при данных значениях аргументов.
- Команда MGL: combine RES adat bdat
- Метод класса
mglData:mglDataCombine (const mglDataA &a)const - Метод класса
mglDataC:mglDataCombine (const mglDataA &a)const - Функция С:
HMDTmgl_data_combine (HCDTdat,HCDTa) Возвращает прямое произведение массивов (наподобие, res[i,j] = adat[i]*bdat[j] и т.д.). Функция возвращает NULL или пустой массив если данные не могут быть созданы при данных значениях аргументов.
- Команда MGL: trace RES dat
- Метод класса
mglData:mglDataTrace ()const - Метод класса
mglDataC:mglDataTrace ()const - Функция С:
HMDTmgl_data_trace (HCDTdat) Возвращает массив диагональных элементов a[i,i] (для 2D данных) или a[i,i,i] (для 3D данных) где i=0...nx-1. В 1D случае возвращается сам массив данных. Размеры массива данных должен быть ny,nz >= nx или ny,nz = 1. Функция возвращает NULL или пустой массив если данные не могут быть созданы при данных значениях аргументов.
- Команда MGL: correl RES adat bdat 'dir'
- Метод класса
mglData:mglDataCorrel (const mglDataA &b,const char *dir)const - Метод класса
mglData:mglDataAutoCorrel (const char *dir)const - Метод класса
mglDataC:mglDataCCorrel (const mglDataA &b,const char *dir)const - Метод класса
mglDataC:mglDataCAutoCorrel (const char *dir)const - Функция С:
HMDTmgl_data_correl (HCDTa,HCDTb,const char *dir) - Функция С:
HADTmgl_datac_correl (HCDTa,HCDTb,const char *dir) Возвращает корреляцию массивов a (или this в C++) и b вдоль направлений dir. При вычислении используется преобразование Фурье. Поэтому может потребоваться вызов функций swap и/или norm перед построением. Функция возвращает NULL или пустой массив если данные не могут быть созданы при данных значениях аргументов.
- Метод класса
mglDataC:mglDataReal ()const - Функция С:
HMDTmgl_datac_real (HCDTdat) Возвращает массив действительных частей массива данных.
- Метод класса
mglDataC:mglDataImag ()const - Функция С:
HMDTmgl_datac_imag (HCDTdat) Возвращает массив мнимых частей массива данных.
- Метод класса
mglDataC:mglDataAbs ()const - Функция С:
HMDTmgl_datac_abs (HCDTdat) Возвращает массив абсолютных значений массива данных.
- Метод класса
mglDataC:mglDataArg ()const - Функция С:
HMDTmgl_datac_arg (HCDTdat) Возвращает массив аргументов массива данных.
- Команда MGL: pulse RES dat 'dir'
- Метод класса
mglData:mglDataPulse (const char *dir)const - Функция С:
HMDTmgl_data_pulse (HCDTdat,const char *dir) Находит параметры импульса вдоль направления dir: максимальное значение (в колонке 0), его положение (в колонке 1), ширина по параболлической аппроксимации (в колонке 3) и по полувысоте (в колонке 2), энергию около максимума (в колонке 4). NAN значения используются для ширин если максимум расположен вблизи границ массива. Отмечу, что для комплексных массивов есть неопределенность определения параметров. Обычно следует использовать квадрат абсолютного значения амплитуды (т.е. |dat[i]|^2). Поэтому MathGL не включает эту функцию в
mglDataC, хотя формально C функция будет работать и для них, но будет использовать абсолютное значение амплитуды (т.е. |dat[i]|). Функция возвращает NULL или пустой массив если данные не могут быть созданы при данных значениях аргументов. См. также max, min, momentum, sum. См. раздел Pulse properties, для примеров кода и графика.
Next: Interpolation, Previous: Make another data, Up: Data processing [Contents][Index]
6.7 Изменение данных
These 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 ‘x’, ‘y’ or ‘z’ characters for 1-st, 2-nd and 3-d dimension correspondingly.
- Команда MGL: cumsum dat 'dir'
- Метод класса
mglData:voidCumSum (const char *dir) - Метод класса
mglDataC:voidCumSum (const char *dir) - Функция С:
voidmgl_data_cumsum (HMDTdat,const char *dir) - Функция С:
voidmgl_datac_cumsum (HADTdat,const char *dir) Суммирует с накоплением в выбранном направлении(ях).
- Команда MGL: integrate dat 'dir'
- Метод класса
mglData:voidIntegral (const char *dir) - Метод класса
mglDataC:voidIntegral (const char *dir) - Функция С:
voidmgl_data_integral (HMDTdat,const char *dir) - Функция С:
voidmgl_datac_integral (HADTdat,const char *dir) Выполняет интегрирование (методом трапеций) в выбранном направлении(ях).
- Команда MGL: diff dat 'dir'
- Метод класса
mglData:voidDiff (const char *dir) - Метод класса
mglDataC:voidDiff (const char *dir) - Функция С:
voidmgl_data_diff (HMDTdat,const char *dir) - Функция С:
voidmgl_datac_diff (HADTdat,const char *dir) Выполняет дифференцирование в выбранном направлении(ях).
- Команда MGL: diff dat xdat ydat [zdat]
- Метод класса
mglData:voidDiff (const mglDataA &x) - Метод класса
mglData:voidDiff (const mglDataA &x,const mglDataA &y) - Метод класса
mglData:voidDiff (const mglDataA &x,const mglDataA &y,const mglDataA &z) - Метод класса
mglDataC:voidDiff (const mglDataA &x) - Метод класса
mglDataC:voidDiff (const mglDataA &x,const mglDataA &y) - Метод класса
mglDataC:voidDiff (const mglDataA &x,const mglDataA &y,const mglDataA &z) - Функция С:
voidmgl_data_diff_par (HMDTdat,HCDTx,HCDTy,HCDTz) - Функция С:
voidmgl_datac_diff_par (HADTdat,HCDTx,HCDTy,HCDTz) Выполняет дифференцирование данных, параметрически зависящих от координат, в направлении x с y, z=constant. Параметр z может быть опущен, что соответствует 2D случаю. Используются следующие формулы (2D случай): da/dx = (a_j*y_i-a_i*y_j)/(x_j*y_i-x_i*y_j), где a_i=da/di, a_j=da/dj обозначает дифференцирование вдоль 1-ой и 2-ой размерности. Похожие формулы используются и в 3D случае. Порядок аргументов можно менять – например, если данные a(i,j) зависят от координат {x(i,j), y(i,j)}, то обычная производная по ‘x’ будет равна
Diff(x,y);, а обычная производная по ‘y’ будет равнаDiff(y,x);.
- Команда MGL: diff2 dat 'dir'
- Метод класса
mglData:voidDiff2 (const char *dir) - Метод класса
mglDataC:voidDiff2 (const char *dir) - Функция С:
voidmgl_data_diff2 (HMDTdat,const char *dir) - Функция С:
voidmgl_datac_diff2 (HADTdat,const char *dir) Выполняет двойное дифференцирование (как в операторе Лапласа) в выбранном направлении(ях).
- Команда MGL: sinfft dat 'dir'
- Метод класса
mglData:voidSinFFT (const char *dir) - Функция С:
voidmgl_data_sinfft (HMDTdat,const char *dir) Выполняет синус преобразование в выбранном направлении(ях). Синус преобразование есть \sum a_j \sin(k j) (см. http://en.wikipedia.org/wiki/Discrete_sine_transform#DST-I).
- Команда MGL: cosfft dat 'dir'
- Метод класса
mglData:voidCosFFT (const char *dir) - Функция С:
voidmgl_data_cosfft (HMDTdat,const char *dir) Выполняет косинус преобразование в выбранном направлении(ях). Синус преобразование есть \sum a_j \cos(k j) (см. http://en.wikipedia.org/wiki/Discrete_cosine_transform#DCT-I).
- Метод класса
mglDataC:voidFFT (const char *dir) - Функция С:
voidmgl_datac_fft (HADTdat,const char *dir) Выполняет фурье преобразование в выбранном направлении(ях). Если строка dir содержит ‘i’, то используется обратное преобразование фурье. Фурье преобразование есть \sum a_j \exp(i k j) (см. http://en.wikipedia.org/wiki/Discrete_Fourier_transform).
- Команда MGL: hankel dat 'dir'
- Метод класса
mglData:voidHankel (const char *dir) - Метод класса
mglDataC:voidHankel (const char *dir) - Функция С:
voidmgl_data_hankel (HMDTdat,const char *dir) - Функция С:
voidmgl_datac_hankel (HADTdat,const char *dir) Выполняет преобразование Ханкеля в выбранном направлении(ях). Преобразование Ханкеля есть \sum a_j J_0(k j) (см. http://en.wikipedia.org/wiki/Hankel_transform).
- Команда MGL: wavelet dat 'dir'
k - Метод класса
mglData:voidWavelet (const char *dir,intk) - Функция С:
voidmgl_data_wavelet (HMDTdat,const char *dir,intk) Выполняет преобразование wavelet в выбранном направлении(ях). Параметр dir задает тип: ‘d’ для daubechies, ‘D’ для центрированного daubechies, ‘h’ для haar, ‘H’ для центрированного haar, ‘b’ для bspline, ‘B’ для центрированного bspline. Если указан символ ‘i’, то выполняется обратное преобразование. Параметр k задает размер преобразования.
- Команда MGL: swap dat 'dir'
- Метод класса
mglData:voidSwap (const char *dir) - Метод класса
mglDataC:voidSwap (const char *dir) - Функция С:
voidmgl_data_swap (HMDTdat,const char *dir) - Функция С:
voidmgl_datac_swap (HADTdat,const char *dir) Меняет местами левую и правую части данных в выбранном направлении(ях). Полезно для отображения результата FFT.
- Команда MGL: roll dat 'dir' num
- Метод класса
mglData:voidRoll (chardir,num) - Метод класса
mglDataC:voidRoll (chardir,num) - Функция С:
voidmgl_data_roll (HMDTdat,chardir,num) - Функция С:
voidmgl_datac_roll (HADTdat,chardir,num) Сдвигает данные на num ячеек в выбранном направлении(ях). Соответствует замене индекса на i->(i+num)%nx при
dir='x'.
- Команда MGL: mirror dat 'dir'
- Метод класса
mglData:voidMirror (const char *dir) - Метод класса
mglDataC:voidMirror (const char *dir) - Функция С:
voidmgl_data_mirror (HMDTdat,const char *dir) - Функция С:
voidmgl_datac_mirror (HADTdat,const char *dir) Отражает данные в выбранном направлении(ях). Соответствует замене индекса на i->n-i. Отмечу, что похожего эффекта на графике можно достичь используя опции (see Command options), например,
surf dat; xrange 1 -1.
- Команда MGL: sew dat ['dir'='xyz'
da=2*pi] - Метод класса
mglData:voidSew (const char *dir,mrealda=2*M_PI) - Функция С:
voidmgl_data_sew (HMDTdat,const char *dir,mrealda) Удаляет скачки данных (например, скачки фазы после обратных тригонометрических функций) с периодом da в выбранном направлении(ях).
- Команда MGL: smooth data ['dir'='xyz']
- Метод класса
mglData:voidSmooth (const char *dir="xyz",mrealdelta=0) - Метод класса
mglDataC:voidSmooth (const char *dir="xyz",mrealdelta=0) - Функция С:
voidmgl_data_smooth (HMDTdat,const char *dir,mrealdelta) - Функция С:
voidmgl_datac_smooth (HADTdat,const char *dir,mrealdelta) Сглаживает данные в выбранном направлении(ях) dir. Строка dirs задает направления вдоль которых будет производиться сглаживание. Строка dir может содержать:
- ‘xyz’ – сглаживание по x-,y-,z-направлениям,
- ‘0’ – ничего не делает,
- ‘3’ – линейное усреднение по 3 точкам,
- ‘5’ – линейное усреднение по 5 точкам,
- ‘d1’...‘d9’ – линейное усреднение по (2*N+1) точкам,
- ‘^’ – определение верхней границы,
- ‘_’ – определение нижней границы.
По умолчанию используется квадратичное усреднение по 5 точкам.
- Команда MGL: envelop dat ['dir'='x']
- Метод класса
mglData:voidEnvelop (chardir='x') - Функция С:
voidmgl_data_envelop (HMDTdat,chardir) Находит огибающую данных в выбранном направлении dir.
- Команда MGL: diffract dat 'how'
q - Метод класса
mglDataC:voidDiffraction (const char *how,mrealq) - Функция С:
voidmgl_datac_diffr (HADTdat,const char *how,mrealq) Вычисляет один шаг диффракции в конечно-разностной схеме с параметром q=\delta t/\delta x^2 используя метод третьего порядка точности. Параметр how может содержать:
- ‘xyz’ для расчета вдоль x-,y-,z-направления;
- ‘r’ для аксиально симметричного лапласиана по направлению x;
- ‘0’ для нулевых граничных условий;
- ‘1’ для постоянных граничных условий;
- ‘2’ для линейных граничных условий;
- ‘3’ для параболлических граничных условий;
- ‘4’ для экспоненциальных граничных условий;
- ‘5’ для гауссовых граничных условий.
- Команда MGL: norm dat
v1 v2 [sym=off dim=0] - Метод класса
mglData:voidNorm (mrealv1=0,mrealv2=1,boolsym=false,longdim=0) - Функция С:
voidmgl_data_norm (HMDTdat,mrealv1,mrealv2,intsym,longdim) Нормирует данные в интервал [v1,v2]. Если sym=
true, то используется симметричный интервал [-max(|v1|,|v2|), max(|v1|,|v2|)]. Изменения применяются только к срезам >=dim.
- Команда MGL: normsl dat
v1 v2['dir'='z'keep=on sym=off] - Метод класса
mglData:voidNormSl (mrealv1=0,mrealv2=1,chardir='z',boolkeep=true,boolsym=false) - Функция С:
voidmgl_data_norm_slice (HMDTdat,mrealv1,mrealv2,chardir,intkeep,intsym) Нормирует данные срез-за-срезом в выбранном направлении dir в интервал [v1,v2]. Если sym=
true, то используется симметричный интервал [-max(|v1|,|v2|), max(|v1|,|v2|)]. Если keep=true, то максимальное значение k-го среза ограничено величиной \sqrt{\sum a_ij(k)/\sum a_ij(0)}.
- Команда MGL: limit dat
val - Метод класса
mglData:voidLimit (mrealval) - Метод класса
mglDataC:voidLimit (mrealval) - Функция С:
voidmgl_data_limit (HMDTdat,mrealval) - Функция С:
voidmgl_datac_limit (HADTdat,mrealval) Ограничивает амплитуду данных диапазоном [-val,val]. При этом сохраняется исходный знак (фаза для комплексных чисел). Эквивалентно операции
a[i] *= abs(a[i])<val?1.:val/abs(a[i]);.
- Команда MGL: coil dat
v1 v2 [sep=on] - Метод класса
mglData:voidCoil (mrealv1,mrealv2,boolsep=true) - Функция С:
voidmgl_data_coil (HMDTdat,mrealv1,mrealv2,intsep) Проецирует периодические данные на диапазон [v1,v2] (аналогично функции
mod()). Разделяет ветки по значениям равнымNANесли sep=true.
- Команда MGL: dilate dat
[val=1 step=1] - Метод класса
mglData:voidDilate (mrealval=1,longstep=1) - Функция С:
voidmgl_data_dilate (HMDTdat,mrealval,longstep) Возвращает "расширенный" на step ячеек массив из 0 и 1 для данных больших порогового значения val.
- Команда MGL: erode dat
[val=1 step=1] - Метод класса
mglData:voidErode (mrealval=1,longstep=1) - Функция С:
voidmgl_data_erode (HMDTdat,mrealval,longstep) Возвращает "суженный" на step ячеек массив из 0 и 1 для данных больших порогового значения val.
Next: Data information, Previous: Data changing, Up: Data processing [Contents][Index]
6.8 Интерполяция
Скрипты MGL могут использовать интерполяцию кубическими сплайнами с помощью команд evaluate или refill. Также можно использовать resize для массива с новыми размерами.
Однако, есть специальные и более быстрые функции при использовании других языков (C/C++/Fortran/Python/...).
- Метод класса
mglData:mrealSpline (mrealx,mrealy=0,mrealz=0)const - Метод класса
mglDataC:dualSpline (mrealx,mrealy=0,mrealz=0)const - Функция С:
mrealmgl_data_spline (HCDTdat,mrealx,mrealy,mrealz) - Функция С:
dualmgl_datac_spline (HCDTdat,mrealx,mrealy,mrealz) Интерполирует данные кубическим сплайном в точке x в [0...nx-1], y в [0...ny-1], z в [0...nz-1].
- Метод класса
mglData:mrealSpline1 (mrealx,mrealy=0,mrealz=0)const - Метод класса
mglDataC:dualSpline1 (mrealx,mrealy=0,mrealz=0)const Интерполирует данные кубическим сплайном в точке x, y, z, где координаты полагаются в интервале [0, 1].
- Метод класса
mglData:mrealSpline (mglPoint&dif,mrealx,mrealy=0,mrealz=0)const - Функция С:
mrealmgl_data_spline_ext (HCDTdat,mrealx,mrealy,mrealz,mreal *dx,mreal *dy,mreal *dz) - Функция С:
dualmgl_datac_spline_ext (HCDTdat,mrealx,mrealy,mrealz,dual *dx,dual *dy,dual *dz) Интерполирует данные кубическим сплайном в точке x в [0...nx-1], y в [0...ny-1], z в [0...nz-1]. Значения производных в точке записываются в dif.
- Метод класса
mglData:mrealSpline1 (mglPoint&dif,mrealx,mrealy=0,mrealz=0)const Интерполирует данные кубическим сплайном в точке x, y, z, где координаты полагаются в интервале [0, 1]. Значения производных в точке записываются в dif.
- Метод класса
mglData:mrealLinear (mrealx,mrealy=0,mrealz=0)const - Метод класса
mglDataC:dualLinear (mrealx,mrealy=0,mrealz=0)const - Функция С:
mrealmgl_data_linear (HCDTdat,mrealx,mrealy,mrealz) - Функция С:
dualmgl_datac_linear (HCDTdat,mrealx,mrealy,mrealz) Интерполирует данные линейной функцией в точке x в [0...nx-1], y в [0...ny-1], z в [0...nz-1].
- Метод класса
mglData:mrealLinear1 (mrealx,mrealy=0,mrealz=0)const - Метод класса
mglDataC:dualLinear1 (mrealx,mrealy=0,mrealz=0)const Интерполирует данные линейной функцией в точке x, y, z, где координаты полагаются в интервале [0, 1].
- Метод класса
mglData:mrealLinear (mglPoint&dif,mrealx,mrealy=0,mrealz=0)const - Метод класса
mglDataC:dualLinear (mglPoint&dif,mrealx,mrealy=0,mrealz=0)const - Функция С:
mrealmgl_data_linear_ext (HCDTdat,mrealx,mrealy,mrealz,mreal *dx,mreal *dy,mreal *dz) - Функция С:
dualmgl_datac_linear_ext (HCDTdat,mrealx,mrealy,mrealz,dual *dx,dual *dy,dual *dz) Интерполирует данные линейной функцией в точке x, y, z, где координаты полагаются в интервале [0, 1]. Значения производных в точке записываются в dif.
- Метод класса
mglData:mrealLinear1 (mglPoint&dif,mrealx,mrealy=0,mrealz=0)const - Метод класса
mglDataC:dualLinear1 (mglPoint&dif,mrealx,mrealy=0,mrealz=0)const Интерполирует данные линейной функцией в точке x, y, z, где координаты полагаются в интервале [0, 1]. Значения производных в точке записываются в dif.
Next: Operators, Previous: Interpolation, Up: Data processing [Contents][Index]
6.9 Информационные функции
В MathGL есть ряд функций для получения свойств массива данных. В MGL скриптах большинство из них реализовано в виде "суффиксов". Суффиксы дают числовое значение некоторой характеристики массива данных. Например, его размер, минимальное и максимальное значение, сумму элементов и т.д. Суффиксы начинаются с точки ‘.’ сразу после массива (без пробелов). Например, a.nx даст размер массива a вдоль x, b(1).max даст максимальное значение второй колонки массива b, (c(:,0)^2).sum даст сумму квадратов в первой строке массива c и т.д.
- Команда MGL: info dat
- Метод класса
mglDataA:const char *PrintInfo ()const - Метод класса
mglDataA:voidPrintInfo (FILE *fp)const - Функция С:
const char *mgl_data_info (HCDTdat) - Fortran процедура:
mgl_data_info (longdat,char *out,intlen) Возвращает строку с информацией о данных (размеры, моменты и пр.) или пишет её в файл. В MGL скрипте печатает её как сообщение.
- Команда MGL: print dat
- Команда MGL: print 'txt'
- Команда MGL: print val
Аналогично info, но сразу выводит в stdout.
- Команда MGL: progress
val max - Метод класса
mglGraph:voidProgress (intval,intmax) - Функция С:
voidmgl_progress (intval,intmax) Отображает прогресс чего-либо как заполненную полоску с относительной длиной val/max. На данный момент работает только в консоли и основанных на FLTK программах, включая
mgllabиmglview.
- MGL suffix: (dat) .nx
- MGL suffix: (dat) .ny
- MGL suffix: (dat) .nz
- Метод класса
mglDataA:longGetNx () - Метод класса
mglDataA:longGetNy () - Метод класса
mglDataA:longGetNz () - Функция С:
longmgl_data_get_nx (HCDTdat) - Функция С:
longmgl_data_get_ny (HCDTdat) - Функция С:
longmgl_data_get_nz (HCDTdat) Возвращает размер данных в направлении x, y и z соответственно.
- MGL suffix: (dat) .max
- Метод класса
mglDataA:mrealMaximal ()const - Функция С:
mrealmgl_data_max (HCDTdat) Возвращает максимальное значение массива данных.
- MGL suffix: (dat) .min
- Метод класса
mglDataA:mrealMinimal ()const - Функция С:
mrealmgl_data_min (HMDTdat)const Возвращает минимальное значение массива данных.
- Метод класса
mglDataA:mrealMinimal (int&i,int&j,int&k)const - Функция С:
mrealmgl_data_min_int (HCDTdat,int*i,int*j,int*k) Возвращает максимальное значение массива данных и сохраняет его положение в переменные i, j, k.
- Метод класса
mglDataA:mrealMaximal (int&i,int&j,int&k)const - Функция С:
mrealmgl_data_max_int (HCDTdat,int*i,int*j,int*k) Возвращает минимальное значение массива данных и сохраняет его положение в переменные i, j, k.
- Метод класса
mglDataA:mrealMinimal (mreal&x,mreal&y,mreal&z)const - Функция С:
mrealmgl_data_min_real (HCDTdat,mreal*x,mreal*y,mreal*z) Возвращает максимальное значение массива данных и его приближенное (интерполированное) положение в переменные x, y, z.
- MGL suffix: (dat) .mx
- MGL suffix: (dat) .my
- MGL suffix: (dat) .mz
- Метод класса
mglDataA:mrealMaximal (mreal&x,mreal&y,mreal&z)const - Функция С:
mrealmgl_data_max_real (HCDTdat,mreal*x,mreal*y,mreal*z) Возвращает минимальное значение массива данных и его приближенное (интерполированное) положение в переменные x, y, z.
- MGL suffix: (dat) .mxf
- MGL suffix: (dat) .myf
- MGL suffix: (dat) .mzf
- MGL suffix: (dat) .mxl
- MGL suffix: (dat) .myl
- MGL suffix: (dat) .mzl
- Метод класса
mglDataA:longMaximal (chardir,longfrom)const - Метод класса
mglDataA:longMaximal (chardir,longfrom,long&p1,long&p2)const - Функция С:
mrealmgl_data_max_firstl (HCDTdat,chardir,longfrom,long*p1,long*p2) Возвращает положение первого (последнего при from<0) максимума в направлении dir, начиная с позиции from. Положение остальных координат для максимума сохраняется в p1, p2.
- MGL suffix: (dat) .sum
- MGL suffix: (dat) .ax
- MGL suffix: (dat) .ay
- MGL suffix: (dat) .az
- MGL suffix: (dat) .aa
- MGL suffix: (dat) .wx
- MGL suffix: (dat) .wy
- MGL suffix: (dat) .wz
- MGL suffix: (dat) .wa
- MGL suffix: (dat) .sx
- MGL suffix: (dat) .sy
- MGL suffix: (dat) .sz
- MGL suffix: (dat) .sa
- MGL suffix: (dat) .kx
- MGL suffix: (dat) .ky
- MGL suffix: (dat) .kz
- MGL suffix: (dat) .ka
- Метод класса
mglDataA:mrealMomentum (chardir,mreal&a,mreal&w)const - Метод класса
mglDataA:mrealMomentum (chardir,mreal&m,mreal&w,mreal&s,mreal&k)const - Функция С:
mrealmgl_data_momentum_val (HCDTdat,chardir,mreal*a,mreal*w,mreal*s,mreal*k) Возвращает нулевой момент (энергию, I=\sum a_i) и записывает первый (среднее, m = \sum \xi_i a_i/I), второй (ширину, w^2 = \sum (\xi_i-m)^2 a_i/I), третий (асимметрия, s = \sum (\xi_i-m)^3 a_i/ I w^3) и четвёртый моменты (эксцесс, k = \sum (\xi_i-m)^4 a_i / 3 I w^4)). Здесь \xi – соответствующая координата если dir равно ‘'x'’, ‘'y'’, ‘'z'’. В противном случае среднее, ширина, асимметрия, эксцесс равны m = \sum a_i/N, w^2 = \sum (a_i-m)^2/N и т.д.
- MGL suffix: (dat) .fst
- Метод класса
mglDataA:mrealFind (const char *cond,int&i,int&j,int&k)const - Функция С:
mrealmgl_data_first (HCDTdat,const char *cond,int*i,int*j,int*k) Находит положение (после заданного в i, j, k) первого не нулевого значения формулы cond. Функция возвращает найденное значение и записывает его положение в i, j, k.
- MGL suffix: (dat) .lst
- Метод класса
mglDataA:mrealLast (const char *cond,int&i,int&j,int&k)const - Функция С:
mrealmgl_data_last (HCDTdat,const char *cond,int*i,int*j,int*k) Находит положение (перед заданного в i, j, k) последнего не нулевого значения формулы cond. Функция возвращает найденное значение и записывает его положение в i, j, k.
- Метод класса
mglDataA:intFind (const char *cond,chardir,inti=0,intj=0,intk=0)const - Функция С:
mrealmgl_data_find (HCDTdat,const char *cond,inti,intj,intk) Возвращает положение первого в направлении dir не нулевого значения формулы cond. Поиск начинается с точки {i,j,k}.
- Метод класса
mglDataA:boolFindAny (const char *cond)const - Функция С:
mrealmgl_data_find_any (HCDTdat,const char *cond) Определяет есть ли хоть одно значение массива, удовлетворяющее условию cond.
Next: Global functions, Previous: Data information, Up: Data processing [Contents][Index]
6.10 Операторы
- Команда MGL: copy DAT dat2 ['eq'='']
- Метод класса
mglData:voidoperator= (const mglDataA &d) Копирует данные из другого экземпляра.
- Команда MGL: copy dat
val - Метод класса
mreal:voidoperator= (mrealval) Устанавливает все значения массива равными val.
- Команда MGL: multo dat dat2
- Команда MGL: multo dat
val - Метод класса
mglData:voidoperator*= (const mglDataA &d) - Метод класса
mglData:voidoperator*= (mreald) - Функция С:
voidmgl_data_mul_dat (HMDTdat,HCDTd) - Функция С:
voidmgl_data_mul_num (HMDTdat,mreald) Поэлементно умножает на массив d или на число val.
- Команда MGL: divto dat dat2
- Команда MGL: divto dat
val - Метод класса
mglData:voidoperator/= (const mglDataA &d) - Метод класса
mglData:voidoperator/= (mreald) - Функция С:
voidmgl_data_div_dat (HMDTdat,HCDTd) - Функция С:
voidmgl_data_div_num (HMDTdat,mreald) Поэлементно делит на массив d или на число val.
- Команда MGL: addto dat dat2
- Команда MGL: addto dat
val - Метод класса
mglData:voidoperator+= (const mglDataA &d) - Метод класса
mglData:voidoperator+= (mreald) - Функция С:
voidmgl_data_add_dat (HMDTdat,HCDTd) - Функция С:
voidmgl_data_add_num (HMDTdat,mreald) Поэлементно прибавляет d или число val.
- Команда MGL: subto dat dat2
- Команда MGL: subto dat
val - Метод класса
mglData:voidoperator-= (const mglDataA &d) - Метод класса
mglData:voidoperator-= (mreald) - Функция С:
voidmgl_data_sub_dat (HMDTdat,HCDTd) - Функция С:
voidmgl_data_sub_num (HMDTdat,mreald) Поэлементно вычитает d или число val.
- Library Function: mglData operator+ (
const mglDataA &a,const mglDataA &b) - Library Function: mglData operator+ (
mreala,const mglDataA &b) - Library Function: mglData operator+ (
const mglDataA &a,mrealb) Возвращает поэлементную сумму данных.
- Library Function: mglData operator- (
const mglDataA &a,const mglDataA &b) - Library Function: mglData operator- (
mreala,const mglDataA &b) - Library Function: mglData operator- (
const mglDataA &a,mrealb) Возвращает поэлементную разность данных.
- Library Function: mglData operator* (
const mglDataA &a,const mglDataA &b) - Library Function: mglData operator* (
mreala,const mglDataA &b) - Library Function: mglData operator* (
const mglDataA &a,mrealb) Возвращает поэлементное произведение данных.
- Library Function: mglData operator/ (
const mglDataA &a,const mglDataA &b) - Library Function: mglData operator/ (
const mglDataA &a,mrealb) Возвращает поэлементное деление данных.
Next: Evaluate expression, Previous: Operators, Up: Data processing [Contents][Index]
6.11 Глобальные функции
Эти функции не методы класса mglData, но они дают дополнительные возможности по обработке данных. Поэтому я поместил их в эту главу.
- Команда MGL: transform DAT 'type' real imag
- Общая функция:
mglDatamglTransform (const mglDataA &real,const mglDataA &imag,const char *type) - Функция С:
HMDTmgl_transform (HCDTreal,HCDTimag,const char *type) Выполняет интегральное преобразование комплексных данных real, imag в выбранном направлении и возвращает модуль результата. Порядок и тип преобразований задается строкой type: первый символ для x-направления, второй для y-направления, третий для z-направления. Возможные символы: ‘f’ – прямое преобразование Фурье, ‘i’ – обратное преобразование Фурье, ‘s’ – синус преобразование, ‘c’ – косинус преобразование, ‘h’ – преобразование Ханкеля, ‘n’ или ‘ ’ – нет преобразования.
- Команда MGL: transforma DAT 'type' ampl phase
- Общая функция:
mglDatamglTransformAconst mglDataA &l,const mglDataA &phase,const char *type) - Функция С:
HMDTmgl_transform_aHCDTampl,HCDTphase,const char *type) Аналогично предыдущему с заданными амплитудой ampl и фазой phase комплексных чисел.
- Команда MGL: fourier reDat imDat 'dir'
- Команда MGL: fourier complexDat 'dir'
- Общая функция:
voidmglFourierconst mglDataA &re,const mglDataA &im,const char *dir) - Метод класса
mglDataC:voidFFT (const char *dir) - Функция С:
voidmgl_data_fourierHCDTre,HCDTim,const char *dir) - Функция С:
voidmgl_datac_fft (HADTdat,const char *dir) Выполняет Фурье преобразование для комплексных данных re+i*im в направлениях dir. Результат помещается обратно в массивы re и im. Если dir содержит ‘i’, то выполняется обратное преобразование Фурье.
- Команда MGL: stfad RES real imag
dn['dir'='x'] - Общая функция:
mglDatamglSTFA (const mglDataA &real,const mglDataA &imag,intdn,chardir='x') - Функция С:
HMDTmgl_data_stfa (HCDTreal,HCDTimag,intdn,chardir) Выполняет оконное преобразование Фурье длиной dn для комплексных данных real, imag и возвращает модуль результата. Например, для dir=‘x’ результат будет иметь размер {int(nx/dn), dn, ny} и будет равен res[i,j,k]=|\sum_d^dn exp(I*j*d)*(real[i*dn+d,k]+I*imag[i*dn+d,k])|/dn.
- Команда MGL: triangulate dat xdat ydat
- Общая функция:
mglDatamglTriangulation (const mglDataA &x,const mglDataA &y) - Функция С:
voidmgl_triangulation_2d (HCDTx,HCDTy) Выполняет триангуляцию Делоне для точек на плоскости и возвращает массив, пригодный для triplot и tricont. См. раздел Making regular data, для примеров кода и графика.
- Команда MGL: tridmat RES ADAT BDAT CDAT DDAT 'how'
- Общая функция:
mglDatamglTridMat (const mglDataA &A,const mglDataA &B,const mglDataA &C,const mglDataA &D,const char *how) - Общая функция:
mglDataCmglTridMatC (const mglDataA &A,const mglDataA &B,const mglDataA &C,const mglDataA &D,const char *how) - Функция С:
HMDTmgl_data_tridmat (HCDTA,HCDTB,HCDTC,HCDTD,const char*how) - Функция С:
HADTmgl_datac_tridmat (HCDTA,HCDTB,HCDTC,HCDTD,const char*how) Возвращает решение трехдиагональной системы уравнений A[i]*x[i-1]+B[i]*x[i]+C[i]*x[i+1]=D[i]. Строка how может содержать:
- ‘xyz’ для решения вдоль x-,y-,z-направлений;
- ‘h’ для решения вдоль диагонали на плоскости x-y (требует квадратную матрицу);
- ‘c’ для использования периодических граничных условий;
- ‘d’ для расчета диффракции/диффузии (т.е. для использования -A[i]*D[i-1]+(2-B[i])*D[i]-C[i]*D[i+1] в правой частиц вместо D[i]).
Размеры массивов A, B, C должны быть одинаковы. Также их размерности должны совпадать со всеми или с "младшими" размерностями массива D. См. раздел PDE solving hints, для примеров кода и графика.
- Команда MGL: pde RES 'ham' ini_re ini_im [
dz=0.1 k0=100] - Общая функция:
mglDatamglPDE (HMGLgr,const char *ham,const mglDataA &ini_re,const mglDataA &ini_im,mrealdz=0.1,mrealk0=100,const char *opt="") - Общая функция:
mglDataCmglPDEc (HMGLgr,const char *ham,const mglDataA &ini_re,const mglDataA &ini_im,mrealdz=0.1,mrealk0=100,const char *opt="") - Функция С:
HMDTmgl_pde_solve (HMGLgr,const char *ham,HCDTini_re,HCDTini_im,mrealdz,mrealk0,const char *opt) - Функция С:
HADTmgl_pde_solve_c (HMGLgr,const char *ham,HCDTini_re,HCDTini_im,mrealdz,mrealk0,const char *opt) Решает уравнение в частных производных du/dz = i*k0*ham(p,q,x,y,z,|u|)[u], где p=-i/k0*d/dx, q=-i/k0*d/dy – псевдо-дифференциальные операторы. Параметры ini_re, ini_im задают начальное распределение поля. Координаты в уравнении и в решении полагаются в диапазоне осей координат. Замечу, что внутри этот диапазон увеличивается в 3/2 раза для уменьшения отражения от границ расчетного интервала. Параметр dz задает шаг по эволюционной координате z. В данный момент использован упрощенный алгоритм, когда все “смешанные” члена (типа ‘x*p’->x*d/dx) исключаются. Например, в 2D случае это функции типа ham = f(p,z) + g(x,z,u). При этом допускаются коммутирующие комбинации (типа ‘x*q’->x*d/dy). Переменная ‘u’ используется для обозначения амплитуды поля |u|. Это позволяет решать нелинейные задачи – например, нелинейное уравнение Шредингера
ham='p^2+q^2-u^2'. Также можно указать мнимую часть для поглощения (типаham = 'p^2+i*x*(x>0)'). См. также apde, qo2d, qo3d. См. раздел PDE solving hints, для примеров кода и графика.
- Команда MGL: apde RES 'ham' ini_re ini_im [
dz=0.1 k0=100] - Общая функция:
mglDatamglAPDE (HMGLgr,const char *ham,const mglDataA &ini_re,const mglDataA &ini_im,mrealdz=0.1,mrealk0=100,const char *opt="") - Общая функция:
mglDataCmglAPDEc (HMGLgr,const char *ham,const mglDataA &ini_re,const mglDataA &ini_im,mrealdz=0.1,mrealk0=100,const char *opt="") - Функция С:
HMDTmgl_pde_solve_adv (HMGLgr,const char *ham,HCDTini_re,HCDTini_im,mrealdz,mrealk0,const char *opt) - Функция С:
HADTmgl_pde_solve_adv_c (HMGLgr,const char *ham,HCDTini_re,HCDTini_im,mrealdz,mrealk0,const char *opt) Решает уравнение в частных производных du/dz = i*k0*ham(p,q,x,y,z,|u|)[u], где p=-i/k0*d/dx, q=-i/k0*d/dy – псевдо-дифференциальные операторы. Параметры ini_re, ini_im задают начальное распределение поля. Координаты в уравнении и в решении полагаются в диапазоне осей координат. Замечу, что внутри этот диапазон увеличивается в 3/2 раза для уменьшения отражения от границ расчетного интервала. Параметр dz задает шаг по эволюционной координате z. Используется достаточно сложный и медленный алгоритм, способный учесть одновременное влияние пространственной дисперсии и неоднородности среды [см. А.А. Балакин, Е.Д. Господчиков, А.Г. Шалашов, Письма ЖЭТФ 104, 701 (2016)]. Переменная ‘u’ используется для обозначения амплитуды поля |u|. Это позволяет решать нелинейные задачи – например, нелинейное уравнение Шредингера
ham='p^2+q^2-u^2'. Также можно указать мнимую часть для поглощения (типаham = 'p^2+i*x*(x>0)'). См. также apde. См. раздел PDE solving hints, для примеров кода и графика.
- Команда MGL: ray RES 'ham'
x0 y0 z0 p0 q0 v0 [dt=0.1 tmax=10] - Общая функция:
mglDatamglRay (const char *ham,mglPointr0,mglPointp0,mrealdt=0.1,mrealtmax=10) - Функция С:
HMDTmgl_ray_trace (const char *ham,mrealx0,mrealy0,mrealz0,mrealpx,mrealpy,mrealpz,mrealdt,mrealtmax) Решает систему геометрооптических уравнений dr/dt = d ham/dp, dp/dt = -d ham/dr. Это гамильтоновы уравнения для траектории частицы в 3D случае. Гамильтониан ham может зависеть от координат ‘x’, ‘y’, ‘z’, импульсов ‘p’=px, ‘q’=py, ‘v’=pz и времени ‘t’: ham = H(x,y,z,p,q,v,t). Начальная точка (при
t=0) задается переменными {x0, y0, z0, p0, q0, v0}. Параметры dt и tmax задают шаг и максимальное время интегрирования. Результат – массив {x,y,z,p,q,v,t} с размером {7 * int(tmax/dt+1) }.
- Команда MGL: ode RES 'df' 'var' ini [
dt=0.1 tmax=10] - Общая функция:
mglDatamglODE (const char *df,const char *var,const mglDataA &ini,mrealdt=0.1,mrealtmax=10) - Общая функция:
mglDataCmglODEc (const char *df,const char *var,const mglDataA &ini,mrealdt=0.1,mrealtmax=10) - Функция С:
HMDTmgl_ode_solve_str (const char *df,const char *var,HCDTini,mrealdt,mrealtmax) - Функция С:
HADTmgl_ode_solve_str_c (const char *df,const char *var,HCDTini,mrealdt,mrealtmax) - Функция С:
HMDTmgl_ode_solve (void (*df)(const mreal *x, mreal *dx, void *par),intn,const mreal *ini,mrealdt,mrealtmax) - Функция С:
HMDTmgl_ode_solve_ex (void (*df)(const mreal *x, mreal *dx, void *par),intn,const mreal *ini,mrealdt,mrealtmax,void (*bord)(mreal *x, const mreal *xprev, void *par)) Решает систему обыкновенных дифференциальных уравнений dx/dt = df(x). Функции df могут быть заданны строкой с разделенными ’;’ формулами (аргумент var задает символы для переменных x[i]) или указателем на функцию, которая заполняет
dxпо заданным значениямx. Параметры ini, dt, tmax задают начальные значения, шаг и максимальное время интегрирования. Функция обрывает расчет при появлении значенийNANилиINF. Результат – массив размером {n * Nt}, где Nt <= int(tmax/dt+1).
- Команда MGL: qo2d RES 'ham' ini_re ini_im ray [
r=1 k0=100xx yy] - Общая функция:
mglDatamglQO2d (const char *ham,const mglDataA &ini_re,const mglDataA &ini_im,const mglDataA &ray,mrealr=1,mrealk0=100,mglData *xx=0,mglData *yy=0) - Общая функция:
mglDatamglQO2d (const char *ham,const mglDataA &ini_re,const mglDataA &ini_im,const mglDataA &ray,mglData &xx,mglData &yy,mrealr=1,mrealk0=100) - Общая функция:
mglDataCmglQO2dc (const char *ham,const mglDataA &ini_re,const mglDataA &ini_im,const mglDataA &ray,mrealr=1,mrealk0=100) - Общая функция:
mglDataCmglQO2dc (const char *ham,const mglDataA &ini_re,const mglDataA &ini_im,const mglDataA &ray,mglData &xx,mglData &yy,mrealr=1,mrealk0=100) - Функция С:
HMDTmgl_qo2d_solve (const char *ham,HCDTini_re,HCDTini_im,HCDTray,mrealr,mrealk0,HMDTxx,HMDTyy) - Функция С:
HADTmgl_qo2d_solve_c (const char *ham,HCDTini_re,HCDTini_im,HCDTray,mrealr,mrealk0,HMDTxx,HMDTyy) - Функция С:
HMDTmgl_qo2d_func (dual (*ham)(mreal u, mreal x, mreal y, mreal px, mreal py, void *par),HCDTini_re,HCDTini_im,HCDTray,mrealr,mrealk0,HMDTxx,HMDTyy) - Функция С:
HADTmgl_qo2d_func_c (dual (*ham)(mreal u, mreal x, mreal y, mreal px, mreal py, void *par),HCDTini_re,HCDTini_im,HCDTray,mrealr,mrealk0,HMDTxx,HMDTyy) Решает уравнение в частных производных du/dt = i*k0*ham(p,q,x,y,|u|)[u] в сопровождающей системе координат, где p=-i/k0*d/dx, q=-i/k0*d/dy – псевдо-дифференциальные операторы. Параметры ini_re, ini_im задают начальное распределение поля. Параметр ray задает опорный луч для сопровождающей системы координат. Можно использовать луч найденный с помощью ray. Опорный луч должен быть достаточно гладкий, чтобы система координат была однозначной и для исключения ошибок интегрирования. Если массивы xx и yy указаны, то в них записываются декартовы координаты для каждой точки найденного решения. См. также pde, qo3d. См. раздел PDE solving hints, для примеров кода и графика.
- Команда MGL: qo3d RES 'ham' ini_re ini_im ray [
r=1 k0=100xx yy zz] - Общая функция:
mglDatamglQO3d (const char *ham,const mglDataA &ini_re,const mglDataA &ini_im,const mglDataA &ray,mrealr=1,mrealk0=100) - Общая функция:
mglDatamglQO3d (const char *ham,const mglDataA &ini_re,const mglDataA &ini_im,const mglDataA &ray,mglData &xx,mglData &yy,mglData &zz,mrealr=1,mrealk0=100) - Общая функция:
mglDataCmglQO3dc (const char *ham,const mglDataA &ini_re,const mglDataA &ini_im,const mglDataA &ray,mrealr=1,mrealk0=100) - Общая функция:
mglDataCmglQO3dc (const char *ham,const mglDataA &ini_re,const mglDataA &ini_im,const mglDataA &ray,mglData &xx,mglData &yy,mglData &zz,mrealr=1,mrealk0=100) - Функция С:
HMDTmgl_qo3d_solve (const char *ham,HCDTini_re,HCDTini_im,HCDTray,mrealr,mrealk0,HMDTxx,HMDTyy,HMDTzz) - Функция С:
HADTmgl_qo3d_solve_c (const char *ham,HCDTini_re,HCDTini_im,HCDTray,mrealr,mrealk0,HMDTxx,HMDTyy,HMDTzz) - Функция С:
HMDTmgl_qo3d_func (dual (*ham)(mreal u, mreal x, mreal y, mreal z, mreal px, mreal py, mreal pz, void *par),HCDTini_re,HCDTini_im,HCDTray,mrealr,mrealk0,HMDTxx,HMDTyy,HMDTzz) - Функция С:
HADTmgl_qo3d_func_c (dual (*ham)(mreal u, mreal x, mreal y, mreal z, mreal px, mreal py, mreal pz, void *par),HCDTini_re,HCDTini_im,HCDTray,mrealr,mrealk0,HMDTxx,HMDTyy,HMDTzz) Решает уравнение в частных производных du/dt = i*k0*ham(p,q,v,x,y,z,|u|)[u] в сопровождающей системе координат, где p=-i/k0*d/dx, q=-i/k0*d/dy, v=-i/k0*d/dz – псевдо-дифференциальные операторы. Параметры ini_re, ini_im задают начальное распределение поля. Параметр ray задает опорный луч для сопровождающей системы координат. Можно использовать луч найденный с помощью ray. Опорный луч должен быть достаточно гладкий, чтобы система координат была однозначной и для исключения ошибок интегрирования. Если массивы xx, yy и zz указаны, то в них записываются декартовы координаты для каждой точки найденного решения. См. также pde, qo2d.
- Команда MGL: jacobian RES xdat ydat [zdat]
- Общая функция:
mglDatamglJacobian (const mglDataA &x,const mglDataA &y) - Общая функция:
mglDatamglJacobian (const mglDataA &x,const mglDataA &y,const mglDataA &z) - Функция С:
HMDTmgl_jacobian_2d (HCDTx,HCDTy) - Функция С:
HMDTmgl_jacobian_3d (HCDTx,HCDTy,HCDTz) Вычисляет якобиан преобразования {i,j,k} в {x,y,z}, где координаты {i,j,k} полагаются нормированными в интервал [0,1]. Якобиан находится по формуле det||dr_\alpha/d\xi_\beta||, где r={x,y,z} и \xi={i,j,k}. Все размерности всех массивов должны быть одинаковы. Данные должны быть трехмерными если указаны все 3 массива {x,y,z} или двумерными если только 2 массива {x,y}.
- Команда MGL: triangulation RES xdat ydat [zdat]
- Общая функция:
mglDatamglTriangulation (const mglDataA &x,const mglDataA &y) - Общая функция:
mglDatamglTriangulation (const mglDataA &x,const mglDataA &y,const mglDataA &z) - Функция С:
HMDTmgl_triangulation_2d (HCDTx,HCDTy) - Функция С:
HMDTmgl_triangulation_3d (HCDTx,HCDTy,HCDTz) Выполняет триангуляцию для произвольно расположенных точек с координатами {x,y,z} (т.е. находит треугольники, соединяющие точки). Первая размерность всех массивов должна быть одинакова
x.nx=y.nx=z.nx. Получившийся массив можно использовать в triplot или tricont для визуализации реконструированной поверхности. См. раздел Making regular data, для примеров кода и графика.
- Общая функция:
mglDatamglGSplineInit (const mglDataA &x,const mglDataA &y) - Общая функция:
mglDataCmglGSplineCInit (const mglDataA &x,const mglDataA &y) - Функция С:
HMDTmgl_gspline_init (HCDTx,HCDTy) - Функция С:
HADTmgl_gsplinec_init (HCDTx,HCDTy) Подготавливает коэффициенты для глобального кубического сплайна.
- Общая функция:
mrealmglGSpline (const mglDataA &coef,mrealdx,mreal *d1=0,mreal *d2=0) - Общая функция:
dualmglGSplineC (const mglDataA &coef,mrealdx,dual *d1=0,dual *d2=0) - Функция С:
mrealmgl_gspline (HCDTcoef,mrealdx,mreal *d1,mreal *d2) - Функция С:
dualmgl_gsplinec (HCDTcoef,mrealdx,dual *d1,dual *d2) Вычисляет глобальный кубический сплайн (а также 1ую и 2ую производные d1, d2 если они не
NULL), используя коэффициенты coef в точке dx+x0 (здесь x0 – 1ый элемент массива x в функцииmglGSpline*Init()).
- Команда MGL: ifs2d RES dat
num[skip=20] - Общая функция:
mglDatamglIFS2d (const mglDataA &dat,longnum,longskip=20) - Функция С:
HMDTmgl_data_ifs_2d (HCDTdat,longnum,longskip) Находит num точек {x[i]=res[0,i], y[i]=res[1,i]} фрактала с использованием итерационной системы функций (IFS). Матрица dat используется для генерации в соответствии с формулами
x[i+1] = dat[0,i]*x[i] + dat[1,i]*y[i] + dat[4,i]; y[i+1] = dat[2,i]*x[i] + dat[3,i]*y[i] + dat[5,i];
Значение
dat[6,i]– весовой коэффициент для i-ой строки матрицы dat. Первые skip итераций будут опущены. Массив dat должен иметь размер по x больше или равный 7. См. также ifs3d, flame2d. См. раздел ifs2d sample, для примеров кода и графика.
- Команда MGL: ifs3d RES dat
num[skip=20] - Общая функция:
mglDatamglIFS3d (const mglDataA &dat,longnum,longskip=20) - Функция С:
HMDTmgl_data_ifs_3d (HCDTdat,longnum,longskip) Находит num точек {x[i]=res[0,i], y[i]=res[1,i], z[i]=res[2,i]} фрактала с использованием итерационной системы функций (IFS). Матрица dat используется для генерации в соответствии с формулами
x[i+1] = dat[0,i]*x[i] + dat[1,i]*y[i] + dat[2,i]*z[i] + dat[9,i]; y[i+1] = dat[3,i]*x[i] + dat[4,i]*y[i] + dat[5,i]*z[i] + dat[10,i]; z[i+1] = dat[6,i]*x[i] + dat[7,i]*y[i] + dat[8,i]*z[i] + dat[11,i];
Значение
dat[12,i]– весовой коэффициент для i-ой строки матрицы dat. Первые skip итераций будут опущены. Массив dat должен иметь размер по x больше или равный 13. См. также ifs2d. См. раздел ifs3d sample, для примеров кода и графика.
- Команда MGL: ifsfile RES 'fname' 'name'
num[skip=20] - Общая функция:
mglDatamglIFSfile (const char *fname,const char *name,longnum,longskip=20) - Функция С:
HMDTmgl_data_ifs_file (const char *fname,const char *name,longnum,longskip) Считывает параметры фрактала name из файла fname и находит num точек для него. Первые skip итераций будут опущены. См. также ifs2d, ifs3d.
Файл IFS может содержать несколько записей. Каждая запись содержит имя фрактала (‘binary’ в примере ниже) и тело в фигурных скобках {} с параметрами фрактала. Символ ‘;’ начинает комментарий. Если имя содержит ‘(3D)’ или ‘(3d)’, то определен 3d IFS фрактал. Пример содержит два фрактала: ‘binary’ – обычный 2d фрактал, и ‘3dfern (3D)’ – 3d фрактал. См. также ifs2d, ifs3d.
binary { ; comment allowed here ; and here .5 .0 .0 .5 -2.563477 -0.000003 .333333 ; also comment allowed here .5 .0 .0 .5 2.436544 -0.000003 .333333 .0 -.5 .5 .0 4.873085 7.563492 .333333 } 3dfern (3D) { .00 .00 0 .0 .18 .0 0 0.0 0.00 0 0.0 0 .01 .85 .00 0 .0 .85 .1 0 -0.1 0.85 0 1.6 0 .85 .20 -.20 0 .2 .20 .0 0 0.0 0.30 0 0.8 0 .07 -.20 .20 0 .2 .20 .0 0 0.0 0.30 0 0.8 0 .07 }
- Команда MGL: flame2d RES dat func
num[skip=20] - Общая функция:
mglDatamglFlame2d (const mglDataA &dat,const mglDataA &func,longnum,longskip=20) - Функция С:
HMDTmgl_data_flame_2d (HCDTdat,HCDTfunc,longnum,longskip) Находит num точек {x[i]=res[0,i], y[i]=res[1,i]} фрактала с использованием итерационной системы функций (IFS). Массив func задает идентификатор функции (func[0,i,j]), ее вес (func[0,i,j]) и аргументы (func[2 ... 5,i,j]). Матрица dat используется для преобразования координат для аргументов функции. Результирующее преобразование имеет вид:
xx = dat[0,i]*x[j] + dat[1,j]*y[i] + dat[4,j]; yy = dat[2,i]*x[j] + dat[3,j]*y[i] + dat[5,j]; x[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]); y[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]);Значение
dat[6,i]– весовой коэффициент для i-ой строки матрицы dat. Первые skip итераций будут опущены. Массив dat должен иметь размер по x больше или равный 7. Доступные идентификаторы функций:mglFlame2d_linear=0, mglFlame2d_sinusoidal, mglFlame2d_spherical, mglFlame2d_swirl, mglFlame2d_horseshoe, mglFlame2d_polar, mglFlame2d_handkerchief,mglFlame2d_heart, mglFlame2d_disc, mglFlame2d_spiral, mglFlame2d_hyperbolic, mglFlame2d_diamond, mglFlame2d_ex, mglFlame2d_julia, mglFlame2d_bent, mglFlame2d_waves, mglFlame2d_fisheye, mglFlame2d_popcorn, mglFlame2d_exponential, mglFlame2d_power, mglFlame2d_cosine, mglFlame2d_rings, mglFlame2d_fan, mglFlame2d_blob, mglFlame2d_pdj, mglFlame2d_fan2, mglFlame2d_rings2, mglFlame2d_eyefish, mglFlame2d_bubble, mglFlame2d_cylinder, mglFlame2d_perspective, mglFlame2d_noise, mglFlame2d_juliaN, mglFlame2d_juliaScope, mglFlame2d_blur, mglFlame2d_gaussian, mglFlame2d_radialBlur, mglFlame2d_pie, mglFlame2d_ngon, mglFlame2d_curl, mglFlame2d_rectangles, mglFlame2d_arch, mglFlame2d_tangent, mglFlame2d_square, mglFlame2d_blade, mglFlame2d_secant, mglFlame2d_rays, mglFlame2d_twintrian, mglFlame2d_cross, mglFlame2d_disc2, mglFlame2d_supershape, mglFlame2d_flower, mglFlame2d_conic, mglFlame2d_parabola, mglFlame2d_bent2, mglFlame2d_bipolar, mglFlame2d_boarders, mglFlame2d_butterfly, mglFlame2d_cell, mglFlame2d_cpow, mglFlame2d_curve, mglFlame2d_edisc, mglFlame2d_elliptic, mglFlame2d_escher, mglFlame2d_foci, mglFlame2d_lazySusan, mglFlame2d_loonie, mglFlame2d_preBlur, mglFlame2d_modulus, mglFlame2d_oscope, mglFlame2d_polar2, mglFlame2d_popcorn2, mglFlame2d_scry, mglFlame2d_separation, mglFlame2d_split, mglFlame2d_splits, mglFlame2d_stripes, mglFlame2d_wedge, mglFlame2d_wedgeJulia, mglFlame2d_wedgeSph, mglFlame2d_whorl, mglFlame2d_waves2, mglFlame2d_exp, mglFlame2d_log, mglFlame2d_sin, mglFlame2d_cos, mglFlame2d_tan, mglFlame2d_sec, mglFlame2d_csc, mglFlame2d_cot, mglFlame2d_sinh, mglFlame2d_cosh, mglFlame2d_tanh, mglFlame2d_sech, mglFlame2d_csch, mglFlame2d_coth, mglFlame2d_auger, mglFlame2d_flux.Значениеdat[6,i]– весовой коэффициент для i-ой строки матрицы dat. Первые skip итераций будут опущены. Размеры массивов должны удовлетворять требованиям: dat.nx>=7, func.nx>=2 и func.nz=dat.ny. См. также ifs2d, ifs3d. См. раздел flame2d sample, для примеров кода и графика.
Next: Special data classes, Previous: Global functions, Up: Data processing [Contents][Index]
6.12 Вычисление выражений
В MathGL есть специальные классы mglExpr и mglExprC для вычисления формул заданных строкой для действительных и комплексных чисел соответственно. Классы определены в #include <mgl2/data.h> и #include <mgl2/datac.h> соответственно. При создании класса происходит разбор формулы в древовидную структуру. А при вычислении только выполняется достаточно быстрый обход по дереву. В данный момент нет различия между верхним и нижним регистром. Если аргумент какой-либо функции лежит вне её области определения, то возвращается NaN. See Textual formulas.
- Конструктор класса
mglExpr:mglExpr (const char *expr) - Конструктор класса
mglExprC:mglExprC (const char *expr) - Функция С:
HMEXmgl_create_expr (const char *expr) - Функция С:
HAEXmgl_create_cexpr (const char *expr) Разбирает формулу expr и создает древовидную структуру, содержащую последовательность вызова функций и операторов для последующего быстрого вычисления формулы с помощью функций
Calc()и/илиCalcD().
- Destructor on
mglExpr:~mglExpr () - Destructor on
mglExprC:~mglExprC () - Функция С:
voidmgl_delete_expr (HMEXex) - Функция С:
voidmgl_delete_cexpr (HAEXex) Удаляет объект типа
mglExpr.
- Метод класса
mglExpr:mrealEval (mrealx,mrealy,mrealz) - Метод класса
mglExprC:dualEval (dualx,dualy,dualz) - Функция С:
mrealmgl_expr_eval (HMEXex,mrealx,mrealy,mrealz) - Функция С:
dualmgl_cexpr_eval (HAEXex,dualx,dualy,dualz) Вычисляет значение формулы для
'x','r'=x,'y','n'=y,'z','t'=z,'a','u'=u.
- Метод класса
mglExpr:mrealEval (mrealvar[26]) - Метод класса
mglExprC:dualEval (dualvar[26]) - Функция С:
mrealmgl_expr_eval_v (HMEXex,mreal *var) - Функция С:
dualmgl_cexpr_eval_v (HMEXex,dual *var) Вычисляет значение формулы для переменных в массиве var[0,...,’z’-’a’].
- Метод класса
mglExpr:mrealDiff (chardir,mrealx,mrealy,mrealz) - Функция С:
mrealmgl_expr_diff (HMEXex,chardir,mrealx,mrealy,mrealz) Вычисляет производную от формулы по переменной dir для
'x','r'=x,'y','n'=y,'z','t'=z,'a','u'=u.
- Метод класса
mglExpr:mrealDiff (chardir,mrealvar[26]) - Функция С:
mrealmgl_expr_diff_v (HMEXex,chardir,mreal *var) Вычисляет производную от формулы по переменной dir для переменных в массиве var[0,...,’z’-’a’].
Previous: Evaluate expression, Up: Data processing [Contents][Index]
6.13 Special data classes
Раздел описывает специальные классы данных mglDataV, mglDataF, mglDataT и mglDataR, которые могут заметно ускорить рисование и обработку данных. Классы определены в #include <mgl2/data.h>. Отмечу, что все функции рисования и обработки данных можно выполнить используя только основные классы mglData и/или mglDataC. Также специальные классы доступны только в коде на С++.
Класс mglDataV
представляет переменную со значениями равнораспределенными в заданном интервале.
- Конструктор
mglDataV:mglDataV (longnx=1,longny=1,longnz=1,mrealv1=0,mrealv2=NaN,chardir='x') Создает переменную "размером" nxxnyxnz, изменяющуюся от v1 до v2 (или постоянную при v2=
NaN) вдоль направления dir.
- Метод класса
mglDataV:voidCreate (longnx=1,longny=1,longnz=1) Задает "размеры" переменной nxxnyxnz.
- Метод класса
mglDataV:voidFill (mrealx1,mrealx2=NaN,chardir='x') Задает диапазон изменения переменной.
Класс mglDataF
представляет функцию, которая будет вызываться вместо обращения к элементам массива (как в классе mglData).
- Конструктор
mglDataF:mglDataF (longnx=1,longny=1,longnz=1) Создает данные "размером" nxxnyxnz с нулевой функцией.
- Метод класса
mglDataF:voidCreate (longnx=1,longny=1,longnz=1) Задает "размеры" данных nxxnyxnz.
- Метод класса
mglDataF:voidSetRanges (mglPointp1,mglPointp2) Задает диапазоны изменения внутренних переменных x,y,z.
- Метод класса
mglDataF:voidSetFormula (const char *func) Задает строку, которая будет разобрана в функцию. Это вариант более чем 10 раз медленнее в сравнении с
SetFunc().
- Метод класса
mglDataF:voidSetFunc (mreal (*f)(mreal x,mreal y,mreal z,void *p),void *p=NULL) Задает указатель на функцию, которая будет использована вместо доступа к элементам массива.
Класс mglDataT
представляет именнованную ссылку на столбец в другом массиве данных.
- Конструктор
mglDataT:mglDataT (const mglDataA &d,longcol=0) Создает ссылку на col-ый столбец данных d.
- Метод класса
mglDataT:voidSetInd (longcol,wchar_tname) - Метод класса
mglDataT:voidSetInd (longcol,const wchar_t *name) Задает ссылку на другой столбец того же массива данных.
Класс mglDataR
представляет именнованную ссылку на строку в другом массиве данных.
- Конструктор
mglDataR:mglDataR (const mglDataA &d,longrow=0) Создает ссылку на row-ую строку данных d.
- Метод класса
mglDataR:voidSetInd (longrow,wchar_tname) - Метод класса
mglDataR:voidSetInd (longrow,const wchar_t *name) Задает ссылку на другой столбец того же массива данных.
Class mglDataW
представляет часоту для FFT в виде массива данных.
- Конструктор
mglDataW:mglDataW (longxx=1,longyy=1,longzz=1,doubledp=0,chardir='x') Задает размеры, направление dir и шаг dp для частоты.
- Метод класса
mglDataR:voidFreq (doubledp,chardir='x') Равномерно распределяет данные с шагом dp в направлении dir.
Class mglDataS
представляет std::vector в виде массива данных.
Next: UDAV, Previous: Data processing, Up: Top [Contents][Index]
7 Скрипты MGL
MathGL имеет встроенный скриптовый язык MGL для обработки и отображения данных. Скрипты MGL могут быть выполнены независимо (с помощью программ UDAV, mglconv, mglview и др. , см. Utilities) или с использованием вызовов библиотеки.
| • MGL definition: | ||
| • Program flow commands: | ||
| • Special comments: | ||
| • LaTeX package: | ||
| • mglParse class: |
Next: Program flow commands, Up: MGL scripts [Contents][Index]
7.1 Основы MGL
Язык MGL достаточно простой. Каждая строка – отдельная команда. Первое слово – имя команды, а все остальные ее аргументы. Команда может иметь до 1000 аргументов (по крайней мере сейчас). Слова разделяются одно от другого пробелом или символом табуляции. Различий между верхним и нижним индексом нет, т.е. переменные a и A идентичны. Символ ‘#’ начинает комментарий – все символы после него игнорируются до конца строки. Исключением является случай, когда ‘#’ входит в строку. Опции команды указываются после символа ‘;’ (see Command options). Символ ‘:’ начинает новую команду (подобно переводу строки) если он расположен не внутри скобок или строки.
Если строка содержит ссылки на внешние параметры (‘$0’, ‘$1’ ... ‘$9’) или макроопределения (‘$a’, ‘$b’ ... ‘$z’), то текущие значения параметров/макроопределений подставляются в строку вместо ссылки до выполнением команды. Это позволяет использовать один и тот же скрипт при различных входных параметрах командной строки или вводить макроопределения по ходу исполнения команд скрипта.
Аргументы команды могут быть строками, переменными или числами.
- Строка – произвольный набор символов между метками ‘'’. Длинные строки могут быть соединены из нескольких линий файла символом ‘\’. Т.е. строки файла ‘'a +'\<br>' b'’ дадут строку ‘'a + b'’ (здесь ‘<br>’ – перевод строки). MGL поддерживает несколько операций над строками:
- Соединение строк и чисел, используя ‘,’ без пробелов (например, ‘'max(u)=',u.max,' a.u.'’ или ‘'u=',!(1+i2)’ для комплексных чисел);
- Получение n-го символа строки, используя ‘[]’ (например, ‘'abc'[1]’ даст
'b'); - Инкремент последнего символа строки, используя ‘+’ (например, ‘'abc'+3’ даст
'abf').
- Обычно переменная имеет имя, состоящее из букв и чисел (должно начинаться с буквы и не быть длиннее 64 символов). Если выражение или переменная начинается с символа ‘!’, то будут использованы комплексные значения. Например, код
new x 100 'x':copy !b !exp(1i*x)создаст массив действительных чисел x и массив комплексных чисел b, который будет равен exp(I*x), где I^2=-1. В качестве переменной можно использовать также и временные массивы, включающие в себя:- срезы (“подмассивы”) массивов данных (подобно команде subdata). Например,
a(1)илиa(1,:)илиa(1,:,:)– вторая строка массива a,a(:,2)илиa(:,2,:)– третий столбец,a(:,:,0)– первый срез и т.д. Также можно выделить часть массива с m-го по n-ый элементa(m:n,:,:)или простоa(m:n). - произвольные комбинации столбцов данных (например,
a('n*w^2/exp(t)')), если столбцы данных были именованы командой idset или в файле данных (в строке начинающейся с##). - произвольное выражение из существующих переменных и констант. Например, ‘sqrt(dat(:,5)+1)’ даст временный массив данных с элементами равными
tmp[i,j] = sqrt(dat[i,5,j]+1). При этом символ ‘`’ возвращает транспонированный массив: ‘`sqrt(dat(:,5)+1)’ и ‘sqrt(`dat(:,5)+1)’ оба дадут временный массив данных с элементами равнымиtmp[i,j] = sqrt(dat[j,5,i]+1). - массивы с элементами заданными в квадратных скобках [], разделенные ‘,’. При этом внутри выражения не должно быть пробелов! Например, ‘[1,2,3]’ даст временный массив из 3 элементов {1, 2, 3}; ‘[[11,12],[21,22]]’ даст матрицу 2*2 и т.д. Элементами такой конструкции могут быть и массивы если их размерности одинаковые, например ‘[v1,v2,...,vn]’.
- результат команд построения новых данных (see Make another data), если они заключены в фигурные скобки {}. Например, ‘{sum dat 'x'}’ даст временный массив, который есть результат суммирования dat вдоль ’x’. Это такой же массив как и tmp, полученный командой ‘sum tmp dat 'x'’. При этом можно использовать вложенные конструкции, например ‘{sum {max dat 'z'} 'x'}’.
Временные массивы не могут стоять в качестве первого аргумента команд, создающих массивы (например, ‘new’, ‘read’, ‘hist’ и т.д.).
- срезы (“подмассивы”) массивов данных (подобно команде subdata). Например,
- К скалярным переменным, кроме собственно чисел, относятся: специальные переменные
nan=#QNAN, inf=бесконечность, rnd=случайное число, pi=3.1415926..., on=1, off=0, all=-1, :=-1, переменные с суффиксами (see Data information), переменные определенные командой define, значения времени (в формате "hh-mm-ss_DD.MM.YYYY", "hh-mm-ss" или "DD.MM.YYYY") . Также массивы размером 1x1x1 считаются скалярами (например, ‘pi/dat.nx’).
Перед первым использованием все переменные должны быть определены с помощью команд, создающих массивы (new, var, list, copy, read, hist, sum и др., см. Data constructor, Data filling и Make another data).
Команды могут иметь несколько наборов аргументов (например, plot ydat и plot xdat ydat). Все аргументы команды для выбранного набора должны быть указаны, однако часть из них могут иметь значения по умолчанию. Такие аргументы в описании команд будут помещены в квадратные скобки [], например plot ydat ['stl'='' zval=nan]. При этом запись [arg1 arg2 arg3 ...] подразумевает [arg1 [arg2 [arg3 ...]]], т.е. опускать можно только аргументы с конца, если вы согласны с их значениями по умолчанию. Например, plot ydat '' 1 или plot ydat '' правильно, а plot ydat 1 не правильно (аргумент 'stl' пропущен).
Можно предоставить несколько вариантов аргументов комманд при использовании символа ‘?’ для их разделения. Конкретный вариант аргумента, используемый при выполнении команды, задается значением команды variant. При этом будет использован последний вариант, если задано слишком большое значение. По умолчанию используется первый вариант (т.е. как при variant 0). Например в следующем коде будет сначала нарисован график синим цветом (первый аргумент ‘b’), а затем красным пунктиром – после variant 1 будет использован второй аргумент ‘r|’:
fplot 'x' 'b'?'r' variant 1 fplot 'x^3' 'b'?'r|'
Next: Special comments, Previous: MGL definition, Up: MGL scripts [Contents][Index]
7.2 Управление ходом выполнения
Ниже собраны команды, управляющие порядком выполнения других команд (условия, циклы, подпрограммы), (пере-)определяют аргументы скрипта и пр. Прочие команды могут быть найдены в главах MathGL core и Data processing. Отмечу, что некоторые из команд (например, define, ask, call, for, func) должны быть расположены на отдельной строке.
- Команда MGL: ask $N 'question'
Задает N-ый аргумент скрипта равным ответу пользователя на вопрос question. Обычно команда показывает диалог с вопросом и полем ввода текста ответа. Здесь N это цифра (0...9) или буква (a...z).
- Команда MGL: define $N smth
Задает N-ый аргумент скрипта равным smth. Отмечу, что smth используется как есть (с символами ‘'’ если присутствуют). Выполняется только подстановка других макроопределений $0...$9, $a...$z. Здесь N это цифра (0...9) или буква (a...z).
- Команда MGL: define name smth
Определяет константу (скаляр) с именем
nameи числовым значениемsmth. Позднее она может быть использована как обычное число.
- Команда MGL: defchr $N smth
Задает N-ый аргумент скрипта равным символу с UTF кодом smth. Здесь N это цифра (0...9) или буква (a...z).
- Команда MGL: defnum $N smth
Задает N-ый аргумент скрипта равным числовому значению smth. Здесь N это цифра (0...9) или буква (a...z).
- Команда MGL: call 'fname' [ARG1 ARG2 ... ARG9]
Переходит к выполнению (вызывает) подпрограммы fname (или внешнего скрипта, если функция не была найдена). Опциональные аргументы передаются в подпрограмму. См. также func.
- Команда MGL: func 'fname' [narg=0]
Определяет подпрограмму с именем fname и задает число требуемых аргументов. Аргументы будут помещены в параметры скрипта $1, $2, ... $9. Отмечу, что выполнение основной программы будет остановлено при встрече
func– действует аналогично комманде stop. См. также return.
- Команда MGL: return
Возвращается из подпрограммы. См. также func.
- Команда MGL: load 'filename'
Загружает дополнительные команды MGL из внешней динамической библиотеки filename. Данная библиотека должна содержать массив с именем
mgl_cmd_extraтипаmglCommand, который содержит описание новых комманд.
- Команда MGL: if dat 'cond'
Начинает блок команд, выполняемый если каждый элемент dat удовлетворяет условию cond.
- Команда MGL: elseif dat 'cond'
Начинает блок команд, выполняемый если предыдущий
ifилиelseifне был выполнен и каждый элемент dat удовлетворяет условию cond.
- Команда MGL: elseif
val Начинает блок команд, выполняемый если предыдущий
ifилиelseifне был выполнен иvalне ноль.
- Команда MGL: for $N
v1 v2 [dv=1] Начинает блок команд, выполняемый в цикле с $N-ым аргументом изменяющимся от v1 до v2 с шагом dv. Здесь N это цифра (0...9) или буква (a...z).
- Команда MGL: for $N dat
Начинает блок команд, выполняемый в цикле с $N-ым аргументом пробегающим значения массива dat. Здесь N это цифра (0...9) или буква (a...z).
- Команда MGL: while
val Переходит к следующей итерации цикла если val не ноль, в противном случае заканчивает цикл.
- Команда MGL: while dat 'cond'
Переходит к следующей итерации цикла если dat удовлетворяет условию cond, в противном случае заканчивает цикл.
- Команда MGL: once
val Определяет код (между
once onиonce off) который будет выполнен только один раз. Полезно для работы с большими данными в программах типа UDAV.
- Команда MGL: variant
val Задает вариант аргумента(ов), разделенных символом ‘?’, для всех последующих комманд.
- Команда MGL: rkstep eq1;... var1;... [
dt=1] Выполняет один шаг решения системы обыкновенных дифференциальных уравнений {var1’ = eq1, ... } с временным шагом dt. Здесь переменные ‘var1’, ... – переменные, определенные в MGL скрипте ранее. При решении используется метод Рунге-Кутта 4-го порядка.
Next: LaTeX package, Previous: Program flow commands, Up: MGL scripts [Contents][Index]
7.3 Специальные комментарии
There are number of special comments for MGL script, which set some global behavior (like, animation, dialog for parameters and so on). All these special comments starts with double sign ##. Let consider them.
- ‘##c
v1 v2 [dv=1]’ Sets the parameter for animation loop relative to variable
$0. Here v1 and v2 are initial and final values, dv is the increment.- ‘##a val’
Adds the parameter val to the list of animation relative to variable
$0. You can use it several times (one parameter per line) or combine it with animation loop ##c.- ‘##d $I kind|label|par1|par2|...’
Creates custom dialog for changing plot properties. Each line adds one widget to the dialog. Here $I is id ($0,$1...$9,$a,$b...$z), label is the label of widget, kind is the kind of the widget:
- ’e’ for editor or input line (parameter is initial value) ,
- ’v’ for spinner or counter (parameters are "ini|min|max|step|big_step"),
- ’s’ for slider (parameters are "ini|min|max|step"),
- ’b’ for check box (parameter is "ini"; also understand "on"=1),
- ’c’ for choice (parameters are possible choices).
Now, it work in FLTK-based
mgllabandmglviewonly.You can make custom dialog in C/C++ code too by using one of following functions.
- Method on
mglWnd:voidMakeDialog (const char *ids,char const * const *args,const char *title) - Method on
mglWnd:voidMakeDialog (const std::string &ids,const std::vector<std::string> &args,const char *title) - C function:
voidmgl_wnd_make_dialog (HMGLgr,const char *ids,char const * const *args,const char *title) Makes custom dialog for parameters ids of element properties defined by args.
At this you need to provide callback function for setting up properties. You can do it by overloading
Param()function ofmglDrawclass or set it manually.
Next: mglParse class, Previous: Special comments, Up: MGL scripts [Contents][Index]
7.4 LaTeX package
There is LaTeX package mgltex (was made by Diego Sejas Viscarra) which allow one to make figures directly from MGL script located in LaTeX file.
For using this package you need to specify --shell-escape option for latex/pdflatex or manually run mglconv tool with produced MGL scripts for generation of images. Don’t forgot to run latex/pdflatex second time to insert generated images into the output document. Also you need to run pdflatex third time to update converted from EPS images if you are using vector EPS output (default).
The package may have following options: draft, final — the same as in the graphicx package; on, off — to activate/deactivate the creation of scripts and graphics; comments, nocomments — to make visible/invisible comments contained inside mglcomment environments; jpg, jpeg, png — to export graphics as JPEG/PNG images; eps, epsz — to export to uncompressed/compressed EPS format as primitives; bps, bpsz — to export to uncompressed/compressed EPS format as bitmap (doesn’t work with pdflatex); pdf — to export to 3D PDF; tex — to export to LaTeX/tikz document.
The package defines the following environments:
- ‘mgl’
It writes its contents to a general script which has the same name as the LaTeX document, but its extension is .mgl. The code in this environment is compiled and the image produced is included. It takes exactly the same optional arguments as the
\includegraphicscommand, plus an additional argument imgext, which specifies the extension to save the image.An example of usage of ‘mgl’ environment would be:
\begin{mglfunc}{prepare2d} new a 50 40 '0.6*sin(pi*(x+1))*sin(1.5*pi*(y+1))+0.4*cos(0.75*pi*(x+1)*(y+1))' new b 50 40 '0.6*cos(pi*(x+1))*cos(1.5*pi*(y+1))+0.4*cos(0.75*pi*(x+1)*(y+1))' \end{mglfunc} \begin{figure}[!ht] \centering \begin{mgl}[width=0.85\textwidth,height=7.5cm] fog 0.5 call 'prepare2d' subplot 2 2 0 : title 'Surf plot (default)' : rotate 50 60 : light on : box : surf a subplot 2 2 1 : title '"\#" style; meshnum 10' : rotate 50 60 : box surf a '#'; meshnum 10 subplot 2 2 2 : title 'Mesh plot' : rotate 50 60 : box mesh a new x 50 40 '0.8*sin(pi*x)*sin(pi*(y+1)/2)' new y 50 40 '0.8*cos(pi*x)*sin(pi*(y+1)/2)' new z 50 40 '0.8*cos(pi*(y+1)/2)' subplot 2 2 3 : title 'parametric form' : rotate 50 60 : box surf x y z 'BbwrR' \end{mgl} \end{figure}- ‘mgladdon’
It adds its contents to the general script, without producing any image.
- ‘mglcode’
Is exactly the same as ‘mgl’, but it writes its contents verbatim to its own file, whose name is specified as a mandatory argument.
- ‘mglscript’
Is exactly the same as ‘mglcode’, but it doesn’t produce any image, nor accepts optional arguments. It is useful, for example, to create a MGL script, which can later be post processed by another package like "listings".
- ‘mglblock’
It writes its contents verbatim to a file, specified as a mandatory argument, and to the LaTeX document, and numerates each line of code.
- ‘mglverbatim’
Exactly the same as ‘mglblock’, but it doesn’t write to a file. This environment doesn’t have arguments.
- ‘mglfunc’
Is used to define MGL functions. It takes one mandatory argument, which is the name of the function, plus one additional argument, which specifies the number of arguments of the function. The environment needs to contain only the body of the function, since the first and last lines are appended automatically, and the resulting code is written at the end of the general script, after the stop command, which is also written automatically. The warning is produced if 2 or more function with the same name is defined.
- ‘mglcomment’
Is used to contain multiline comments. This comments will be visible/invisible in the output document, depending on the use of the package options
commentsandnocomments(see above), or the\mglcommentsand\mglnocommentscommands (see bellow).- ‘mglsetup’
If many scripts with the same code are to be written, the repetitive code can be written inside this environment only once, then this code will be used automatically every time the ‘\mglplot’ command is used (see below). It takes one optional argument, which is a name to be associated to the corresponding contents of the environment; this name can be passed to the ‘\mglplot’ command to use the corresponding block of code automatically (see below).
The package also defines the following commands:
- ‘\mglplot’
It takes one mandatory argument, which is MGL instructions separated by the symbol ‘:’ this argument can be more than one line long. It takes the same optional arguments as the ‘mgl’ environment, plus an additional argument setup, which indicates the name associated to a block of code inside a ‘mglsetup’ environment. The code inside the mandatory argument will be appended to the block of code specified, and the resulting code will be written to the general script.
An example of usage of ‘\mglplot’ command would be:
\begin{mglsetup} box '@{W9}' : axis \end{mglsetup} \begin{mglsetup}[2d] box : axis grid 'xy' ';k' \end{mglsetup} \begin{mglsetup}[3d] rotate 50 60 box : axis : grid 'xyz' ';k' \end{mglsetup} \begin{figure}[!ht] \centering \mglplot[scale=0.5]{new a 200 'sin(pi*x)' : plot a '2B'} \end{figure} \begin{figure}[!ht] \centering \mglplot[scale=0.5,setup=2d]{ fplot 'sin(pi*x)' '2B' : fplot 'cos(pi*x^2)' '2R' } \end{figure} \begin{figure}[!ht] \centering \mglplot[setup=3d]{fsurf 'sin(pi*x)+cos(pi*y)'} \end{figure}- ‘\mglgraphics’
This command takes the same optional arguments as the ‘mgl’ environment, and one mandatory argument, which is the name of a MGL script. This command will compile the corresponding script and include the resulting image. It is useful when you have a script outside the LaTeX document, and you want to include the image, but you don’t want to type the script again.
- ‘\mglinclude’
This is like ‘\mglgraphics’ but, instead of creating/including the corresponding image, it writes the contents of the MGL script to the LaTeX document, and numerates the lines.
- ‘\mgldir’
This command can be used in the preamble of the document to specify a directory where LaTeX will save the MGL scripts and generate the corresponding images. This directory is also where ‘\mglgraphics’ and ‘\mglinclude’ will look for scripts.
- ‘\mglquality’
Adjust the quality of the MGL graphics produced similarly to quality.
- ‘\mgltexon, \mgltexoff’
Activate/deactivate the creation of MGL scripts and images. Notice these commands have local behavior in the sense that their effect is from the point they are called on.
- ‘\mglcomment, \mglnocomment’
Make visible/invisible the contents of the
mglcommentenvironments. These commands have local effect too.- ‘\mglTeX’
It just pretty prints the name of the package.
As an additional feature, when an image is not found or cannot be included, instead of issuing an error, mgltex prints a box with the word ‘MGL image not found’ in the LaTeX document.
Previous: LaTeX package, Up: MGL scripts [Contents][Index]
7.5 mglParse class
Класс разбирает и выполняет скрипты MGL. Он определен в #include <mgl2/mgl.h>.
Основная функция класса mglParse – Execute(), выполняющая построчный разбор скрипта. Также есть вспомогательные функции для поиска и создания переменных MGL (объектов, производных от mglDataA). Эти функции полезны для отображения значений массивов во внешних объектах (например, в отдельном окне) или для предоставления доступа к внутренним массивам. Функция AllowSetSize() позволяет запретить изменение размера картинки (запрещает команду setsize). Функция AllowFileIO() позволяет запретить доступ к файлам на диске.
- Конструктор класса
mglParse:mglParse (boolsetsize=false) - Конструктор класса
mglParse:mglParse (HMPRpr) - Конструктор класса
mglParse:mglParse (mglParse &pr) - Функция С:
HMPRmgl_create_parser () Создает экземпляр класса
mglParseи устанавливает значение AllowSetSize.
- Деструктор класса
mglParse:~mglParse () - Функция С:
voidmgl_delete_parser (HMPRp) Удаляет экземпляр класса.
- Метод класса
mglParse:voidExecute (mglGraph *gr,const char *text) - Метод класса
mglParse:voidExecute (mglGraph *gr,const wchar_t *text) - Функция С:
voidmgl_parse_text (HMGLgr,HMPRp,const char *text) - Функция С:
voidmgl_parse_textw (HMGLgr,HMPRp,const wchar_t *text) Выполняет построчно скрипт MGL, содержащийся в text. Строки считаются разделенными символом ‘\n’. Это основная функция класса.
- Метод класса
mglParse:voidExecute (mglGraph *gr,FILE *fp,boolprint=false) - Функция С:
voidmgl_parse_file (HMGLgr,HMPRp,FILE *fp,intprint) Аналогично предыдущему, но скрипт читается из файла fp. Если print=
true, то предупреждения и информационные сообщения печатаются в stdout.
- Метод класса
mglParse:intParse (mglGraph *gr,const char *str,longpos=0) - Метод класса
mglParse:intParse (mglGraph *gr,const wchar_t *str,longpos=0) - Функция С:
intmgl_parse_line (HMGLgr,HMPRp,const char *str,intpos) - Функция С:
intmgl_parse_linew (HMGLgr,HMPRp,const wchar_t *str,intpos) Выполняет строку str с выводом графики на gr. Возвращает код ошибки: 0 – нет ошибок, 1 – неправильные аргументы, 2 – неизвестная команда, 3 – строка слишком длинная, 4 – нет закрывающей скобки или ‘'’. Аргумент pos задает позицию строки в документе/файле для использования в команде for.
- Метод класса
mglParse:mglDataCalc (const char *formula) - Метод класса
mglParse:mglDataCalc (const wchar_t *formula) - Функция С:
HMDTmgl_parser_calc (HMPRp,const char *formula) - Функция С:
HMDTmgl_parser_calcw (HMPRp,const wchar_t *formula) Разбирает строку formula и возвращает полученный массив. В отличие от
AddVar()илиFindVar(), это обычный массив данных, который следует удалить после использования.
- Метод класса
mglParse:mglDataCCalcComplex (const char *formula) - Метод класса
mglParse:mglDataCCalcComplex (const wchar_t *formula) - Функция С:
HADTmgl_parser_calc_complex (HMPRp,const char *formula) - Функция С:
HADTmgl_parser_calc_complexw (HMPRp,const wchar_t *formula) Разбирает строку formula и возвращает полученный массив с комплексными значениями. В отличие от
AddVar()илиFindVar(), это обычный массив данных, который следует удалить после использования.
- Метод класса
mglParse:voidAddParam (intn,const char *str) - Метод класса
mglParse:voidAddParam (intn,const wchar_t *str) - Функция С:
voidmgl_parser_add_param (HMPRp,intid,const char *val) - Функция С:
voidmgl_parser_add_paramw (HMPRp,intid,const wchar_t *val) Устанавливает значение n-го параметра строкой str (n=0, 1 ... ’z’-’a’+10). Строка str не должна содержать символ ‘$’.
- Метод класса
mglParse:mglVar *FindVar (const char *name) - Метод класса
mglParse:mglVar *FindVar (const wchar_t *name) - Функция С:
HMDTmgl_parser_find_var (HMPRp,const char *name) - Функция С:
HMDTmgl_parser_find_varw (HMPRp,const wchar_t *name) Возвращает указатель на переменную с именем name или
NULLесли переменная отсутствует. Используйте эту функцию для добавления внешних массивов в скрипт. Не удаляйте полученный массив!
- Метод класса
mglParse:mglVar *AddVar (const char *name) - Метод класса
mglParse:mglVar *AddVar (const wchar_t *name) - Функция С:
HMDTmgl_parser_add_var (HMPRp,const char *name) - Функция С:
HMDTmgl_parser_add_varw (HMPRp,const wchar_t *name) Возвращает указатель на переменную с именем name. Если переменная отсутствует, то она будет создана. Используйте эту функцию для добавления внешних массивов в скрипт. Не удаляйте полученный массив!
- Метод класса
mglParse:voidOpenHDF (const char *fname) - Функция С:
voidmgl_parser_openhdf (HMPRpr,const char *fname) Читает все массивы данных из HDF5 файла fname и создает переменные MGL с соответствующими именами. Если имя данных начинается с ‘!’, то будут созданы комплексные массивы.
- Метод класса
mglParse(C++):voidDeleteVar (const char *name) - Метод класса
mglParse(C++):voidDeleteVar (const wchar_t *name) - Функция С:
voidmgl_parser_del_var (HMPRp,const char *name) - Функция С:
voidmgl_parser_del_varw (HMPRp,const wchar_t *name) Удаляет переменную по имени name.
- Метод класса
mglParse(C++):voidDeleteAll () - Функция С:
voidmgl_parser_del_all (HMPRp) Удаляет все переменные и сбрасывает список команд к списку по умолчанию в данном классе.
- Метод класса
mglParse:voidRestoreOnce () - Функция С:
voidmgl_parser_restore_once (HMPRp) Восстанавливает состояние флага Once.
- Метод класса
mglParse:voidAllowSetSize (boola) - Функция С:
voidmgl_parser_allow_setsize (HMPRp,inta) Разрешает/запрещает команду setsize.
- Метод класса
mglParse:voidAllowFileIO (boola) - Функция С:
voidmgl_parser_allow_file_io (HMPRp,inta) Разрешает/запрещает команды чтения файлов.
- Метод класса
mglParse:voidAllowDllCall (boola) - Функция С:
voidmgl_parser_allow_dll_call (HMPRp,inta) Разрешает/запрещает команду load.
- Метод класса
mglParse:voidStop () - Функция С:
voidmgl_parser_stop (HMPRp) Посылает сигнал завершения выполнения для следующей команды.
- Метод класса
mglParse:voidSetVariant (intvar=0) - Функция С:
voidmgl_parser_variant (HMPRp,intvar=0) Задает вариант аргумента(ов), разделенных символом ‘?’, для всех последующих комманд.
- Метод класса
mglParse:voidStartID (intid=0) - Функция С:
voidmgl_parser_start_id (HMPRp,intid) Задает начальный id (обычно это номер строки) первой строки при последующем выполнении скрипта.
- Метод класса
mglParse:longGetCmdNum () - Функция С:
longmgl_parser_cmd_num (HMPRp) Возвращает число зарегистрированных команд MGL.
- Метод класса
mglParse:const char *GetCmdName (longid) - Функция С:
const char *mgl_parser_cmd_name (HMPRp,longid) Возвращает имя команды MGL с заданным номером id.
- Метод класса
mglParse:intCmdType (const char *name) - Функция С:
intmgl_parser_cmd_type (HMPRp,const char *name) Возвращает тип команды MGL с именем name. Типы команд: 0 – не команда, 1 - графики по данным, 2 - прочие графики, 3 - настройка, 4 - обработка данных, 5 - создание данных, 6 - трансформация, 7 - ход выполнения, 8 - 1d графики, 9 - 2d графики, 10 - 3d графики, 11 - двойные графики, 12 - векторные поля, 13 - оси координат, 14 - примитивы, 15 - настройка осей, 16 - текст/легенда, 17 - изменение данных.
- Метод класса
mglParse:const char *CmdFormat (const char *name) - Функция С:
const char *mgl_parser_cmd_frmt (HMPRp,const char *name) Возвращает формат аргументов команды MGL с именем name.
- Метод класса
mglParse:const char *CmdDesc (const char *name) - Функция С:
const char *mgl_parser_cmd_desc (HMPRp,const char *name) Возвращает описание команды MGL с именем name.
- Метод класса
mglParse:voidRK_Step (const char *eqs,const char *vars,mrealdt=1) - Метод класса
mglParse:voidRK_Step (const wchar_t *eqs,const wchar_t *vars,mrealdt=1) - Функция С:
voidmgl_rk_step (HMPRp,const char *eqs,const char *vars,mrealdt) - Функция С:
voidmgl_rk_step_w (HMPRp,const wchar_t *eqs,const wchar_t *vars,mrealdt) Make one step for ordinary differential equation(s) {var1’ = eq1, ... } with time-step dt. Here strings eqs and vars contain the equations and variable names separated by symbol ‘;’. The variable(s) ‘var1’, ... are the ones, defined in MGL script previously. The Runge-Kutta 4-th order method is used.
Next: Other classes, Previous: MGL scripts, Up: Top [Contents][Index]
8 UDAV
UDAV (Universal Data Array Visualizator) is cross-platform program for data arrays visualization based on MathGL library. It support wide spectrum of graphics, simple script language and visual data handling and editing. It has window interface for data viewing, changing and plotting. Also it can execute MGL scripts, setup and rotate graphics and so on. UDAV hot-keys can be found in the appendix Hot-keys for UDAV.
| • UDAV overview: | ||
| • UDAV dialogs: | ||
| • UDAV hints: |
Next: UDAV dialogs, Up: UDAV [Contents][Index]
8.1 UDAV overview
UDAV have main window divided by 2 parts in general case and optional bottom panel(s). Left side contain tabs for MGL script and data arrays. Right side contain tabs with graphics itself, with list of variables and with help on MGL. Bottom side may contain the panel with MGL messages and warnings, and the panel with calculator.
Main window is shown on the figure above. You can see the script (at left) with current line highlighted by light-yellow, and result of its execution at right. Each panel have its own set of toolbuttons.
Editor toolbuttons allow: open and save script from/to file; undo and redo changes; cut, copy and paste selection; find/replace text; show dialogs for command arguments and for plot setup; show calculator at bottom.
Graphics toolbuttons allow: enable/disable additional transparency and lighting; show grid of absolute coordinates; enable mouse rotation; restore image view; refresh graphics (execute the script); stop calculation; copy graphics into clipboard; add primitives (line, curve, box, rhombus, ellipse, mark, text) to the image; change view angles manually. Vertical toolbuttons allow: shift and zoom in/out of image as whole; show next and previous frame of animation, or start animation (if one present).
Graphics panel support plot editing by mouse.
- Axis range can be changed by mouse wheel or by dragging image by middle mouse button. Right button show popup menu. Left button show the coordinates of mouse click. At this double click will highlight plot under mouse and jump to the corresponded string of the MGL script.
- Pressing "mouse rotation" toolbutton will change mouse actions: dragging by left button will rotate plot, middle button will shift the plot as whole, right button will zoom in/out plot as whole and add perspective, mouse wheel will zoom in/out plot as whole.
- Manual primitives can be added by pressing corresponding toolbutton. They can be shifted as whole at any time by mouse dragging. At this double click open dialog with its properties. If toolbutton "grid of absolute coordinates" is pressed then editing of active points for primitives is enabled.
Short command description and list of its arguments are shown at the status-bar, when you move cursor to the new line of code. You can press F1 to see more detailed help on special panel.
Also you can look the current list of variables, its dimensions and its size in the memory (right side of above figure). Toolbuttons allow: create new variable, edit variable, delete variable, preview variable plot and its properties, refresh list of variables. Pressing on any column will sort table according its contents. Double click on a variable will open panel with data cells of the variable, where you can view/edit each cell independently or apply a set of transformations.
Finally, pressing F2 or F4 you can show/hide windows with messages/warnings and with calculator. Double click on a warning in message window will jump to corresponding line in editor. Calculator allow you type expression by keyboard as well as by toolbuttons. It know about all current variables, so you can use them in formulas.
Next: UDAV hints, Previous: UDAV overview, Up: UDAV [Contents][Index]
8.2 UDAV dialogs
There are a set of dialogs, which allow change/add a command, setup global plot properties, or setup UDAV itself.
One of most interesting dialog (hotkey Meta-C or Win-C) is dialog which help to enter new command or change arguments of existed one. It allows consequently select the category of command, command name in category and appropriate set of command arguments. At this right side show detailed command description. Required argument(s) are denoted by bold text. Strings are placed in apostrophes, like 'txt'. Buttons below table allow to call dialogs for changing style of command (if argument 'fmt' is present in the list of command arguments); to set variable or expression for argument(s); to add options for command. Note, you can click on a cell to enter value, or double-click to call corresponding dialog.
Dialog for changing style can be called independently, but usually is called from New command dialog or by double click on primitive. It contain 3 tabs: one for pen style, one for color scheme, one for text style. You should select appropriate one. Resulting string of style and sample picture are shown at bottom of dialog. Usually it can be called from New command dialog.
Dialog for entering variable allow to select variable or expression which can be used as argument of a command. Here you can select the variable name; range of indexes in each directions; operation which will be applied (like, summation, finding minimal/maximal values and so on). Usually it can be called from New command dialog.
Dialog for command options allow to change Command options. Usually it can be called from New command dialog.
Another interesting dialog, which help to select and properly setup a subplot, inplot, columnplot, stickplot and similar commands.
There is dialog for setting general plot properties, including tab for setting lighting properties. It can be called by called by hotkey ??? and put setup commands at the beginning of MGL script.
Also you can set or change script parameters (‘$0’ ... ‘$9’, see MGL definition).
Finally, there is dialog for UDAV settings. It allow to change most of things in UDAV appearance and working, including colors of keywords and numbers, default font and image size, and so on (see figure above).
There are also a set of dialogs for data handling, but they are too simple and clear. So, I will not put them here.
Previous: UDAV dialogs, Up: UDAV [Contents][Index]
8.3 UDAV hints
- You can shift axis range by pressing middle button and moving mouse. Also, you can zoom in/out axis range by using mouse wheel.
- You can rotate/shift/zoom whole plot by mouse. Just press ’Rotate’ toolbutton, click image and hold a mouse button: left button for rotation, right button for zoom/perspective, middle button for shift.
- You may quickly draw the data from file. Just use: udav ’filename.dat’ in command line.
- You can copy the current image to clipboard by pressing Ctrl-Shift-C. Later you can paste it directly into yours document or presentation.
- You can export image into a set of format (EPS, SVG, PNG, JPEG) by pressing right mouse button inside image and selecting ’Export as ...’.
- You can setup colors for script highlighting in Property dialog. Just select menu item ’Settings/Properties’.
- You can save the parameter of animation inside MGL script by using comment started from ’##a ’ or ’##c ’ for loops.
- New drawing never clears things drawn already. For example, you can make a surface with contour lines by calling commands ’surf’ and ’cont’ one after another (in any order).
- You can put several plots in the same image by help of commands ’subplot’ or ’inplot’.
- All indexes (of data arrays, subplots and so on) are always start from 0.
- You can edit MGL file in any text editor. Also you can run it in console by help of commands:
mglconv,mglview. - You can use command ’once on|off’ for marking the block which should be executed only once. For example, this can be the block of large data reading/creating/handling. Press F9 (or menu item ’Graphics/Reload’) to re-execute this block.
- You can use command ’stop’ for terminating script parsing. It is useful if you don’t want to execute a part of script.
- You can type arbitrary expression as input argument for data or number. In last case (for numbers), the first value of data array is used.
- There is powerful calculator with a lot of special functions. You can use buttons or keyboard to type the expression. Also you can use existed variables in the expression.
- The calculator can help you to put complex expression in the script. Just type the expression (which may depend on coordinates x,y,z and so on) and put it into the script.
- You can easily insert file or folder names, last fitted formula or numerical value of selection by using menu Edit|Insert.
- The special dialog (Edit|Insert|New Command) help you select the command, fill its arguments and put it into the script.
- You can put several plotting commands in the same line or in separate function, for highlighting all of them simultaneously.
Next: All samples, Previous: UDAV, Up: Top [Contents][Index]
9 Other classes
There are few end-user classes: mglGraph (see MathGL core), mglWindow and mglGLUT (see Widget classes), mglData (see Data processing), mglParse (see MGL scripts). Exactly these classes I recommend to use in most of user programs. All methods in all of these classes are inline and have exact C/Fortran analogue functions. This give compiler independent binary libraries for MathGL.
However, sometimes you may need to extend MathGL by writing yours own plotting functions or handling yours own data structures. In these cases you may need to use low-level API. This chapter describes it.
The internal structure of MathGL is rather complicated. There are C++ classes mglBase, mglCanvas, ... for drawing primitives and positioning the plot (blue ones in the figure). There is a layer of C functions, which include interface for most important methods of these classes. Also most of plotting functions are implemented as C functions. After it, there are “inline” front-end classes which are created for user convenience (yellow ones in the figure). Also there are widgets for FLTK and Qt libraries (green ones in the figure).
Below I show how this internal classes can be used.
| • mglBase class: | ||
| • mglDataA class: | ||
| • mglColor class: | ||
| • mglPoint class: |
Next: mglDataA class, Up: Other classes [Contents][Index]
9.1 Define new kind of plot (mglBase class)
Basically most of new kinds of plot can be created using just MathGL primitives (see Primitives). However the usage of mglBase methods can give you higher speed of drawing and better control of plot settings.
All plotting functions should use a pointer to mglBase class (or HMGL type in C functions) due to compatibility issues. Exactly such type of pointers are used in front-end classes (mglGraph, mglWindow) and in widgets (QMathGL, Fl_MathGL).
MathGL tries to remember all vertexes and all primitives and plot creation stage, and to use them for making final picture by demand. Basically for making plot, you need to add vertexes by AddPnt() function, which return index for new vertex, and call one of primitive drawing function (like mark_plot(), arrow_plot(), line_plot(), trig_plot(), quad_plot(), text_plot()), using vertex indexes as argument(s). AddPnt() function use 2 mreal numbers for color specification. First one is positioning in textures – integer part is texture index, fractional part is relative coordinate in the texture. Second number is like a transparency of plot (or second coordinate in the 2D texture).
I don’t want to put here detailed description of mglBase class. It was rather well documented in mgl2/base.h file. I just show and example of its usage on the base of circle drawing.
First, we should prototype new function circle() as C function.
#ifdef __cplusplus
extern "C" {
#endif
void circle(HMGL gr, mreal x, mreal y, mreal z, mreal r, const char *stl, const char *opt);
#ifdef __cplusplus
}
#endif
This is done for generating compiler independent binary. Because only C-functions have standard naming mechanism, the same for any compilers.
Now, we create a C++ file and put the code of function. I’ll write it line by line and try to comment all important points.
void circle(HMGL gr, mreal x, mreal y, mreal z, mreal r, const char *stl, const char *opt)
{
First, we need to check all input arguments and send warnings if something is wrong. In our case it is negative value of r argument. We just send warning, since it is not critical situation – other plot still can be drawn.
if(r<=0) { gr->SetWarn(mglWarnNeg,"Circle"); return; }
Next step is creating a group. Group keep some general setting for plot (like options) and useful for export in 3d files.
static int cgid=1; gr->StartGroup("Circle",cgid++);
Now let apply options. Options are rather useful things, generally, which allow one easily redefine axis range(s), transparency and other settings (see Command options).
gr->SaveState(opt);
I use global setting for determining the number of points in circle approximation. Note, that user can change MeshNum by options easily.
const int n = gr->MeshNum>1?gr->MeshNum : 41;
Let try to determine plot specific flags. MathGL functions expect that most of flags will be sent in string. In our case it is symbol ‘@’ which set to draw filled circle instead of border only (last will be default). Note, you have to handle NULL as string pointer.
bool fill = mglchr(stl,'@');
Now, time for coloring. I use palette mechanism because circle have few colors: one for filling and another for border. SetPenPal() function parse input string and write resulting texture index in pal. Function return the character for marker, which can be specified in string str. Marker will be plotted at the center of circle. I’ll show on next sample how you can use color schemes (smooth colors) too.
long pal=0; char mk=gr->SetPenPal(stl,&pal);
Next step, is determining colors for filling and for border. First one for filling.
mreal c=gr->NextColor(pal), d;
Second one for border. I use black color (call gr->AddTexture('k')) if second color is not specified.
mreal k=(gr->GetNumPal(pal)>1)?gr->NextColor(pal):gr->AddTexture('k');
If user want draw only border (fill=false) then I use first color for border.
if(!fill) k=c;
Now we should reserve space for vertexes. This functions need n for border, n+1 for filling and 1 for marker. So, maximal number of vertexes is 2*n+2. Note, that such reservation is not required for normal work but can sufficiently speed up the plotting.
gr->Reserve(2*n+2);
We’ve done with setup and ready to start drawing. First, we need to add vertex(es). Let define NAN as normals, since I don’t want handle lighting for this plot,
mglPoint q(NAN,NAN);
and start adding vertexes. First one for central point of filling. I use -1 if I don’t need this point. The arguments of AddPnt() function is: mglPoint(x,y,z) – coordinate of vertex, c – vertex color, q – normal at vertex, -1 – vertex transparency (-1 for default), 3 bitwise flag which show that coordinates will be scaled (0x1) and will not be cutted (0x2).
long n0,n1,n2,m1,m2,i; n0 = fill ? gr->AddPnt(mglPoint(x,y,z),c,q,-1,3):-1;
Similar for marker, but we use different color k.
n2 = mk ? gr->AddPnt(mglPoint(x,y,z),k,q,-1,3):-1;
Draw marker.
if(mk) gr->mark_plot(n2,mk);
Time for drawing circle itself. I use -1 for m1, n1 as sign that primitives shouldn’t be drawn for first point i=0.
for(i=0,m1=n1=-1;i<n;i++)
{
Each function should check Stop variable and return if it is non-zero. It is done for interrupting drawing for system which don’t support multi-threading.
if(gr->Stop) return;
Let find coordinates of vertex.
mreal t = i*2*M_PI/(n-1.);
mglPoint p(x+r*cos(t), y+r*sin(t), z);
Save previous vertex and add next one
n2 = n1; n1 = gr->AddPnt(p,c,q,-1,3);
and copy it for border but with different color. Such copying is much faster than adding new vertex using AddPnt().
m2 = m1; m1 = gr->CopyNtoC(n1,k);
Now draw triangle for filling internal part
if(fill) gr->trig_plot(n0,n1,n2);
and draw line for border.
gr->line_plot(m1,m2); }
Drawing is done. Let close group and return.
gr->EndGroup(); }
Another sample I want to show is exactly the same function but with smooth coloring using color scheme. So, I’ll add comments only in the place of difference.
void circle_cs(HMGL gr, mreal x, mreal y, mreal z, mreal r, const char *stl, const char *opt)
{
In this case let allow negative radius too. Formally it is not the problem for plotting (formulas the same) and this allow us to handle all color range.
//if(r<=0) { gr->SetWarn(mglWarnNeg,"Circle"); return; }
static int cgid=1; gr->StartGroup("CircleCS",cgid++);
gr->SaveState(opt);
const int n = gr->MeshNum>1?gr->MeshNum : 41;
bool fill = mglchr(stl,'@');
Here is main difference. We need to create texture for color scheme specified by user
long ss = gr->AddTexture(stl);
But we need also get marker and color for it (if filling is enabled). Let suppose that marker and color is specified after ‘:’. This is standard delimiter which stop color scheme entering. So, just lets find it and use for setting pen.
const char *pen=0; if(stl) pen = strchr(stl,':'); if(pen) pen++;
The substring is placed in pen and it will be used as line style.
long pal=0; char mk=gr->SetPenPal(pen,&pal);
Next step, is determining colors for filling and for border. First one for filling.
mreal c=gr->GetC(ss,r);
Second one for border.
mreal k=gr->NextColor(pal);
The rest part is the same as in previous function.
if(!fill) k=c;
gr->Reserve(2*n+2);
mglPoint q(NAN,NAN);
long n0,n1,n2,m1,m2,i;
n0 = fill ? gr->AddPnt(mglPoint(x,y,z),c,q,-1,3):-1;
n2 = mk ? gr->AddPnt(mglPoint(x,y,z),k,q,-1,3):-1;
if(mk) gr->mark_plot(n2,mk);
for(i=0,m1=n1=-1;i<n;i++)
{
if(gr->Stop) return;
mreal t = i*2*M_PI/(n-1.);
mglPoint p(x+r*cos(t), y+r*sin(t), z);
n2 = n1; n1 = gr->AddPnt(p,c,q,-1,3);
m2 = m1; m1 = gr->CopyNtoC(n1,k);
if(fill) gr->trig_plot(n0,n1,n2);
gr->line_plot(m1,m2);
}
gr->EndGroup();
}
The last thing which we can do is derive our own class with new plotting functions. Good idea is to derive it from mglGraph (if you don’t need extended window), or from mglWindow (if you need to extend window). So, in our case it will be
class MyGraph : public mglGraph
{
public:
inline void Circle(mglPoint p, mreal r, const char *stl="", const char *opt="")
{ circle(p.x,p.y,p.z, r, stl, opt); }
inline void CircleCS(mglPoint p, mreal r, const char *stl="", const char *opt="")
{ circle_cs(p.x,p.y,p.z, r, stl, opt); }
};
Note, that I use inline modifier for using the same binary code with different compilers.
So, the complete sample will be
#include <mgl2/mgl.h>
//---------------------------------------------------------
#ifdef __cplusplus
extern "C" {
#endif
void circle(HMGL gr, mreal x, mreal y, mreal z, mreal r, const char *stl, const char *opt);
void circle_cs(HMGL gr, mreal x, mreal y, mreal z, mreal r, const char *stl, const char *opt);
#ifdef __cplusplus
}
#endif
//---------------------------------------------------------
class MyGraph : public mglGraph
{
public:
inline void CircleCF(mglPoint p, mreal r, const char *stl="", const char *opt="")
{ circle(p.x,p.y,p.z, r, stl, opt); }
inline void CircleCS(mglPoint p, mreal r, const char *stl="", const char *opt="")
{ circle_cs(p.x,p.y,p.z, r, stl, opt); }
};
//---------------------------------------------------------
void circle(HMGL gr, mreal x, mreal y, mreal z, mreal r, const char *stl, const char *opt)
{
if(r<=0) { gr->SetWarn(mglWarnNeg,"Circle"); return; }
static int cgid=1; gr->StartGroup("Circle",cgid++);
gr->SaveState(opt);
const int n = gr->MeshNum>1?gr->MeshNum : 41;
bool fill = mglchr(stl,'@');
long pal=0;
char mk=gr->SetPenPal(stl,&pal);
mreal c=gr->NextColor(pal), d;
mreal k=(gr->GetNumPal(pal)>1)?gr->NextColor(pal):gr->AddTexture('k');
if(!fill) k=c;
gr->Reserve(2*n+2);
mglPoint q(NAN,NAN);
long n0,n1,n2,m1,m2,i;
n0 = fill ? gr->AddPnt(mglPoint(x,y,z),c,q,-1,3):-1;
n2 = mk ? gr->AddPnt(mglPoint(x,y,z),k,q,-1,3):-1;
if(mk) gr->mark_plot(n2,mk);
for(i=0,m1=n1=-1;i<n;i++)
{
if(gr->Stop) return;
mreal t = i*2*M_PI/(n-1.);
mglPoint p(x+r*cos(t), y+r*sin(t), z);
n2 = n1; n1 = gr->AddPnt(p,c,q,-1,3);
m2 = m1; m1 = gr->CopyNtoC(n1,k);
if(fill) gr->trig_plot(n0,n1,n2);
gr->line_plot(m1,m2);
}
gr->EndGroup();
}
//---------------------------------------------------------
void circle_cs(HMGL gr, mreal x, mreal y, mreal z, mreal r, const char *stl, const char *opt)
{
static int cgid=1; gr->StartGroup("CircleCS",cgid++);
gr->SaveState(opt);
const int n = gr->MeshNum>1?gr->MeshNum : 41;
bool fill = mglchr(stl,'@');
long ss = gr->AddTexture(stl);
const char *pen=0;
if(stl) pen = strchr(stl,':');
if(pen) pen++;
long pal=0;
char mk=gr->SetPenPal(pen,&pal);
mreal c=gr->GetC(ss,r);
mreal k=gr->NextColor(pal);
if(!fill) k=c;
gr->Reserve(2*n+2);
mglPoint q(NAN,NAN);
long n0,n1,n2,m1,m2,i;
n0 = fill ? gr->AddPnt(mglPoint(x,y,z),c,q,-1,3):-1;
n2 = mk ? gr->AddPnt(mglPoint(x,y,z),k,q,-1,3):-1;
if(mk) gr->mark_plot(n2,mk);
for(i=0,m1=n1=-1;i<n;i++)
{
if(gr->Stop) return;
mreal t = i*2*M_PI/(n-1.);
mglPoint p(x+r*cos(t), y+r*sin(t), z);
n2 = n1; n1 = gr->AddPnt(p,c,q,-1,3);
m2 = m1; m1 = gr->CopyNtoC(n1,k);
if(fill) gr->trig_plot(n0,n1,n2);
gr->line_plot(m1,m2);
}
gr->EndGroup();
}
//---------------------------------------------------------
int main()
{
MyGraph gr;
gr.Box();
// first let draw circles with fixed colors
for(int i=0;i<10;i++)
gr.CircleCF(mglPoint(2*mgl_rnd()-1, 2*mgl_rnd()-1), mgl_rnd());
// now let draw circles with color scheme
for(int i=0;i<10;i++)
gr.CircleCS(mglPoint(2*mgl_rnd()-1, 2*mgl_rnd()-1), 2*mgl_rnd()-1);
}
Next: mglColor class, Previous: mglBase class, Up: Other classes [Contents][Index]
9.2 User defined types (mglDataA class)
mglData class have abstract predecessor class mglDataA. Exactly the pointers to mglDataA instances are used in all plotting functions and some of data processing functions. This was done for taking possibility to define yours own class, which will handle yours own data (for example, complex numbers, or differently organized data). And this new class will be almost the same as mglData for plotting purposes.
However, the most of data processing functions will be slower as if you used mglData instance. This is more or less understandable – I don’t know how data in yours particular class will be organized, and couldn’t optimize the these functions generally.
There are few virtual functions which must be provided in derived classes. This functions give:
- the sizes of the data (
GetNx,GetNy,GetNz), - give data value and numerical derivatives for selected cell (
v,dvx,dvy,dvz), - give maximal and minimal values (
Maximal,Minimal) – you can use provided functions (likemgl_data_maxandmgl_data_min), but yours own realization can be more efficient, - give access to all element as in single array (
vthr) – you need this only if you want using MathGL’s data processing functions.
Let me, for example define class mglComplex which will handle complex number and draw its amplitude or phase, depending on flag use_abs:
#include <complex>
#include <mgl2/mgl.h>
#define dual std::complex<double>
class mglComplex : public mglDataA
{
public:
long nx; ///< number of points in 1st dimensions ('x' dimension)
long ny; ///< number of points in 2nd dimensions ('y' dimension)
long nz; ///< number of points in 3d dimensions ('z' dimension)
dual *a; ///< data array
bool use_abs; ///< flag to use abs() or arg()
inline mglComplex(long xx=1,long yy=1,long zz=1)
{ a=0; use_abs=true; Create(xx,yy,zz); }
virtual ~mglComplex() { if(a) delete []a; }
/// Get sizes
inline long GetNx() const { return nx; }
inline long GetNy() const { return ny; }
inline long GetNz() const { return nz; }
/// Create or recreate the array with specified size and fill it by zero
inline void Create(long mx,long my=1,long mz=1)
{ nx=mx; ny=my; nz=mz; if(a) delete []a;
a = new dual[nx*ny*nz]; }
/// Get maximal value of the data
inline mreal Maximal() const { return mgl_data_max(this); }
/// Get minimal value of the data
inline mreal Minimal() const { return mgl_data_min(this); }
protected:
inline mreal v(long i,long j=0,long k=0) const
{ return use_abs ? abs(a[i+nx*(j+ny*k)]) : arg(a[i+nx*(j+ny*k)]); }
inline mreal vthr(long i) const
{ return use_abs ? abs(a[i]) : arg(a[i]); }
inline mreal dvx(long i,long j=0,long k=0) const
{ long i0=i+nx*(j+ny*k);
std::complex<double> res=i>0? (i<nx-1? (a[i0+1]-a[i0-1])/2.:a[i0]-a[i0-1]) : a[i0+1]-a[i0];
return use_abs? abs(res) : arg(res); }
inline mreal dvy(long i,long j=0,long k=0) const
{ long i0=i+nx*(j+ny*k);
std::complex<double> res=j>0? (j<ny-1? (a[i0+nx]-a[i0-nx])/2.:a[i0]-a[i0-nx]) : a[i0+nx]-a[i0];
return use_abs? abs(res) : arg(res); }
inline mreal dvz(long i,long j=0,long k=0) const
{ long i0=i+nx*(j+ny*k), n=nx*ny;
std::complex<double> res=k>0? (k<nz-1? (a[i0+n]-a[i0-n])/2.:a[i0]-a[i0-n]) : a[i0+n]-a[i0];
return use_abs? abs(res) : arg(res); }
};
int main()
{
mglComplex dat(20);
for(long i=0;i<20;i++)
dat.a[i] = 3*exp(-0.05*(i-10)*(i-10))*dual(cos(M_PI*i*0.3), sin(M_PI*i*0.3));
mglGraph gr;
gr.SetRange('y', -M_PI, M_PI); gr.Box();
gr.Plot(dat,"r","legend 'abs'");
dat.use_abs=false;
gr.Plot(dat,"b","legend 'arg'");
gr.Legend();
gr.WritePNG("complex.png");
return 0;
}
Next: mglPoint class, Previous: mglDataA class, Up: Other classes [Contents][Index]
9.3 mglColor class
Structure for working with colors. This structure is defined in #include <mgl2/type.h>.
There are two ways to set the color in MathGL. First one is using of mreal values of red, green and blue channels for precise color definition. The second way is the using of character id. There are a set of characters specifying frequently used colors. Normally capital letter gives more dark color than lowercase one. See Line styles.
- Method on mglColor:
mglColor (mrealR,mrealG,mrealB,mrealA=1) Constructor sets the color by mreal values of Red, Green, Blue and Alpha channels. These values should be in interval [0,1].
- Method on mglColor:
mglColor (charc='k',mrealbright=1) Constructor sets the color from character id. The black color is used by default. Parameter br set additional “lightness” of color.
- Method on mglColor:
voidSet (mrealR,mrealG,mrealB,mrealA=1) Sets color from values of Red, Green, Blue and Alpha channels. These values should be in interval [0,1].
- Method on mglColor:
voidSet (mglColorc,mrealbright=1) Sets color as “lighted” version of color c.
- Method on mglColor:
booloperator== (const mglColor &c) - Method on mglColor:
booloperator!= (const mglColor &c) Compare with another color
- Library Function: mglColor operator+ (
const mglColor &a,const mglColor &b) Adds colors by its RGB values.
- Library Function:
mglColoroperator- (const mglColor &a,const mglColor &b) Subtracts colors by its RGB values.
- Library Function:
mglColoroperator* (const mglColor &a,mrealb) - Library Function:
mglColoroperator* (mreala,const mglColor &b) Multiplies color by number.
Previous: mglColor class, Up: Other classes [Contents][Index]
9.4 mglPoint class
Structure describes point in space. This structure is defined in #include <mgl2/type.h>
- Parameter of mglPoint:
mrealx, y, z, c Point coordinates {x,y,z} and one extra value c used for amplitude, transparency and so on. By default all values are zero.
- Method on mglPoint:
mglPoint (mrealX=0,mrealY=0,mrealZ=0,mrealC=0) Constructor sets the color by mreal values of Red, Green, Blue and Alpha channels. These values should be in interval [0,1].
- Method on mglPoint:
mrealval (inti) Returns point component: x for i=0, y for i=1, z for i=2, c for i=3.
- Library Function:
mglPointoperator+ (const mglPoint &a,const mglPoint &b) Point of summation (summation of vectors).
- Library Function:
mglPointoperator- (const mglPoint &a,const mglPoint &b) Point of difference (difference of vectors).
- Library Function:
mglPointoperator* (mreala,const mglPoint &b) - Library Function:
mglPointoperator* (const mglPoint &a,mrealb) Multiplies (scale) points by number.
- Library Function:
mglPointoperator/ (const mglPoint &a,mrealb) Multiplies (scale) points by number 1/b.
- Library Function:
mglPointoperator/ (const mglPoint &a,const mglPoint &b) Return vector of element-by-element product.
- Library Function:
mglPointoperator^ (const mglPoint &a,const mglPoint &b) Cross-product of vectors.
- Library Function:
mglPointoperator& (const mglPoint &a,const mglPoint &b) The part of a which is perpendicular to vector b.
- Library Function:
mglPointoperator| (const mglPoint &a,const mglPoint &b) The part of a which is parallel to vector b.
- Library Function:
booloperator== (const mglPoint &a,const mglPoint &b) Return true if points are the same.
- Library Function:
booloperator!= (const mglPoint &a,const mglPoint &b) Return true if points are different.
Next: Symbols and hot-keys, Previous: Other classes, Up: Top [Contents][Index]
10 All samples
This chapter contain alphabetical list of MGL and C++ samples for most of MathGL graphics and features.
Next: 3wave sample, Up: All samples [Contents][Index]
10.1 Functions for initialization
This section contain functions for input data for most of further samples.
MGL code:
func 'prepare1d' new y 50 3 modify y '0.7*sin(2*pi*x)+0.5*cos(3*pi*x)+0.2*sin(pi*x)' modify y 'sin(2*pi*x)' 1 modify y 'cos(2*pi*x)' 2 new x1 50 'x' new x2 50 '0.05-0.03*cos(pi*x)' new y1 50 '0.5-0.3*cos(pi*x)' new y2 50 '-0.3*sin(pi*x)' return func 'prepare2d' new a 50 40 '0.6*sin(pi*(x+1))*sin(1.5*pi*(y+1))+0.4*cos(0.75*pi*(x+1)*(y+1))' new b 50 40 '0.6*cos(pi*(x+1))*cos(1.5*pi*(y+1))+0.4*cos(0.75*pi*(x+1)*(y+1))' return func 'prepare3d' new c 61 50 40 '-2*(x^2+y^2+z^4-z^2)+0.2' new d 61 50 40 '1-2*tanh((x+y)*(x+y))' return func 'prepare2v' new a 20 30 '0.6*sin(pi*(x+1))*sin(1.5*pi*(y+1))+0.4*cos(0.75*pi*(x+1)*(y+1))' new b 20 30 '0.6*cos(pi*(x+1))*cos(1.5*pi*(y+1))+0.4*cos(0.75*pi*(x+1)*(y+1))' return func 'prepare3v' define $1 pow(x*x+y*y+(z-0.3)*(z-0.3)+0.03,1.5) define $2 pow(x*x+y*y+(z+0.3)*(z+0.3)+0.03,1.5) new ex 10 10 10 '0.2*x/$1-0.2*x/$2' new ey 10 10 10 '0.2*y/$1-0.2*y/$2' new ez 10 10 10 '0.2*(z-0.3)/$1-0.2*(z+0.3)/$2' return
C++ code:
void mgls_prepare1d(mglData *y, mglData *y1, mglData *y2, mglData *x1, mglData *x2)
{
long n=50;
if(y) y->Create(n,3);
if(x1) x1->Create(n);
if(x2) x2->Create(n);
if(y1) y1->Create(n);
if(y2) y2->Create(n);
for(long i=0;i<n;i++)
{
double xx = i/(n-1.);
if(y)
{
y->a[i] = 0.7*sin(2*M_PI*xx) + 0.5*cos(3*M_PI*xx) + 0.2*sin(M_PI*xx);
y->a[i+n] = sin(2*M_PI*xx);
y->a[i+2*n] = cos(2*M_PI*xx);
}
if(y1) y1->a[i] = 0.5+0.3*cos(2*M_PI*xx);
if(y2) y2->a[i] = 0.3*sin(2*M_PI*xx);
if(x1) x1->a[i] = xx*2-1;
if(x2) x2->a[i] = 0.05+0.03*cos(2*M_PI*xx);
}
}
//-----------------------------------------------------------------------------
void mgls_prepare2d(mglData *a, mglData *b, mglData *v)
{
long n=50,m=40;
if(a) a->Create(n,m);
if(b) b->Create(n,m);
if(v) { v->Create(9); v->Fill(-1,1); }
for(long j=0;j<m;j++) for(long i=0;i<n;i++)
{
double x = i/(n-1.), y = j/(m-1.);
long i0 = i+n*j;
if(a) a->a[i0] = 0.6*sin(2*M_PI*x)*sin(3*M_PI*y)+0.4*cos(3*M_PI*x*y);
if(b) b->a[i0] = 0.6*cos(2*M_PI*x)*cos(3*M_PI*y)+0.4*cos(3*M_PI*x*y);
}
}
//-----------------------------------------------------------------------------
void mgls_prepare3d(mglData *a, mglData *b)
{
long n=61,m=50,l=40;
if(a) a->Create(n,m,l);
if(b) b->Create(n,m,l);
for(long k=0;k<l;k++) for(long j=0;j<m;j++) for(long i=0;i<n;i++)
{
double x=2*i/(n-1.)-1, y=2*j/(m-1.)-1, z=2*k/(l-1.)-1;
long i0 = i+n*(j+m*k);
if(a) a->a[i0] = -2*(x*x + y*y + z*z*z*z - z*z - 0.1);
if(b) b->a[i0] = 1-2*tanh((x+y)*(x+y));
}
}
//-----------------------------------------------------------------------------
void mgls_prepare2v(mglData *a, mglData *b)
{
long n=20,m=30;
if(a) a->Create(n,m);
if(b) b->Create(n,m);
for(long j=0;j<m;j++) for(long i=0;i<n;i++)
{
double x=i/(n-1.), y=j/(m-1.);
long i0 = i+n*j;
if(a) a->a[i0] = 0.6*sin(2*M_PI*x)*sin(3*M_PI*y)+0.4*cos(3*M_PI*x*y);
if(b) b->a[i0] = 0.6*cos(2*M_PI*x)*cos(3*M_PI*y)+0.4*cos(3*M_PI*x*y);
}
}
//-----------------------------------------------------------------------------
void mgls_prepare3v(mglData *ex, mglData *ey, mglData *ez)
{
long n=10;
double z0=0.3;
if(!ex || !ey || !ez) return;
ex->Create(n,n,n); ey->Create(n,n,n); ez->Create(n,n,n);
for(long k=0;k<n;k++) for(long j=0;j<n;j++) for(long i=0;i<n;i++)
{
double x=2*i/(n-1.)-1, y=2*j/(n-1.)-1, z=2*k/(n-1.)-1;
long i0 = i+n*(j+k*n);
double r1 = pow(x*x+y*y+(z-z0)*(z-z0)+0.03,1.5);
double r2 = pow(x*x+y*y+(z+z0)*(z+z0)+0.03,1.5);
ex->a[i0]=0.2*x/r1 - 0.2*x/r2;
ey->a[i0]=0.2*y/r1 - 0.2*y/r2;
ez->a[i0]=0.2*(z-z0)/r1 - 0.2*(z+z0)/r2;
}
}
//-----------------------------------------------------------------------------
Next: alpha sample, Previous: initialization sample, Up: All samples [Contents][Index]
10.2 Sample ‘3wave’
Example of complex ode on basis of 3-wave decay.
MGL code:
define t 50 ode !r '-b*f;a*conj(f);a*conj(b)-0.1*f' 'abf' [1,1e-3,0] 0.1 t ranges 0 t 0 r.max plot r(0) 'b';legend 'a' plot r(1) 'g';legend 'b' plot r(2) 'r';legend 'f' axis:box:legend
C++ code:
void smgl_3wave(mglGraph *gr)
{
gr->SubPlot(1,1,0,"<_");
if(big!=3) gr->Title("Complex ODE sample");
double t=50;
mglData ini; ini.SetList(3, 1., 1e-3, 0.);
mglDataC r(mglODEc("-b*f;a*conj(f);a*conj(b)-0.1*f","abf",ini,0.1,t));
gr->SetRanges(0, t, 0, r.Maximal());
gr->Plot(r.SubData(0),"b","legend 'a'");
gr->Plot(r.SubData(1),"g","legend 'b'");
gr->Plot(r.SubData(2),"r","legend 'f'");
gr->Axis(); gr->Box(); gr->Legend();
}
Next: apde sample, Previous: 3wave sample, Up: All samples [Contents][Index]
10.3 Sample ‘alpha’
Example of light and alpha (transparency).
MGL code:
call 'prepare2d' subplot 2 2 0:title 'default':rotate 50 60:box surf a subplot 2 2 1:title 'light on':rotate 50 60:box light on:surf a subplot 2 2 3:title 'light on; alpha on':rotate 50 60:box alpha on:surf a subplot 2 2 2:title 'alpha on':rotate 50 60:box light off:surf a
C++ code:
void smgl_alpha(mglGraph *gr) // alpha and lighting
{
mglData a; mgls_prepare2d(&a);
gr->SubPlot(2,2,0); gr->Title("default"); gr->Rotate(50,60);
gr->Box(); gr->Surf(a);
gr->SubPlot(2,2,1); gr->Title("light on"); gr->Rotate(50,60);
gr->Box(); gr->Light(true); gr->Surf(a);
gr->SubPlot(2,2,3); gr->Title("alpha on; light on"); gr->Rotate(50,60);
gr->Box(); gr->Alpha(true); gr->Surf(a);
gr->SubPlot(2,2,2); gr->Title("alpha on"); gr->Rotate(50,60);
gr->Box(); gr->Light(false); gr->Surf(a);
}
Next: area sample, Previous: alpha sample, Up: All samples [Contents][Index]
10.4 Sample ‘apde’
Comparison of advanced PDE solver (apde) and ordinary one (pde).
MGL code:
ranges -1 1 0 2 0 2 new ar 256 'exp(-2*(x+0.0)^2)' new ai 256 apde res1 'exp(-x^2-p^2)' ar ai 0.01:transpose res1 pde res2 'exp(-x^2-p^2)' ar ai 0.01 subplot 1 2 0 '_':title 'Advanced PDE solver' ranges 0 2 -1 1:crange res1 dens res1:box axis:xlabel '\i z':ylabel '\i x' text -0.5 0.2 'i\partial_z\i u = exp(-\i x^2+\partial_x^2)[\i u]' 'y' subplot 1 2 1 '_':title 'Simplified PDE solver' dens res2:box axis:xlabel '\i z':ylabel '\i x' text -0.5 0.2 'i\partial_z\i u \approx\ exp(-\i x^2)\i u+exp(\partial_x^2)[\i u]' 'y'
C++ code:
void smgl_apde(mglGraph *gr)
{
gr->SetRanges(-1,1,0,2,0,2);
mglData ar(256), ai(256); gr->Fill(ar,"exp(-2*(x+0.0)^2)");
mglData res1(gr->APDE("exp(-x^2-p^2)",ar,ai,0.01)); res1.Transpose();
mglData res2(gr->PDE("exp(-x^2-p^2)",ar,ai,0.01));
gr->SubPlot(1,2,0,"_"); gr->Title("Advanced PDE solver");
gr->SetRanges(0,2,-1,1); gr->SetRange('c',res1);
gr->Dens(res1); gr->Axis(); gr->Box();
gr->Label('x',"\\i z"); gr->Label('y',"\\i x");
gr->Puts(mglPoint(-0.5,0.2),"i\\partial_z\\i u = exp(-\\i x^2+\\partial_x^2)[\\i u]","y");
gr->SubPlot(1,2,1,"_"); gr->Title("Simplified PDE solver");
gr->Dens(res2); gr->Axis(); gr->Box();
gr->Label('x',"\\i z"); gr->Label('y',"\\i x");
gr->Puts(mglPoint(-0.5,0.2),"i\\partial_z\\i u \\approx\\ exp(-\\i x^2)\\i u+exp(\\partial_x^2)[\\i u]","y");
}
Next: aspect sample, Previous: apde sample, Up: All samples [Contents][Index]
10.5 Sample ‘area’
Function area fill the area between curve and axis plane. It support gradient filling if 2 colors per curve is specified.
MGL code:
call 'prepare1d' origin 0 0 0 subplot 2 2 0 '':title 'Area plot (default)':box:area y subplot 2 2 1 '':title '2 colors':box:area y 'cbgGyr' subplot 2 2 2 '':title '"!" style':box:area y '!' new yc 30 'sin(pi*x)':new xc 30 'cos(pi*x)':new z 30 'x' subplot 2 2 3:title '3d variant':rotate 50 60:box area xc yc z 'r' area xc -yc z 'b#'
C++ code:
void smgl_area(mglGraph *gr)
{
mglData y; mgls_prepare1d(&y); gr->SetOrigin(0,0,0);
if(big!=3) { gr->SubPlot(2,2,0,""); gr->Title("Area plot (default)"); }
gr->Box(); gr->Area(y);
if(big==3) return;
gr->SubPlot(2,2,1,""); gr->Title("2 colors"); gr->Box(); gr->Area(y,"cbgGyr");
gr->SubPlot(2,2,2,""); gr->Title("'!' style"); gr->Box(); gr->Area(y,"!");
gr->SubPlot(2,2,3); gr->Title("3d variant"); gr->Rotate(50,60); gr->Box();
mglData yc(30), xc(30), z(30); z.Modify("2*x-1");
yc.Modify("sin(pi*(2*x-1))"); xc.Modify("cos(pi*2*x-pi)");
gr->Area(xc,yc,z,"r");
yc.Modify("-sin(pi*(2*x-1))"); gr->Area(xc,yc,z,"b#");
}
Next: axial sample, Previous: area sample, Up: All samples [Contents][Index]
10.6 Sample ‘aspect’
Example of subplot, inplot, rotate, aspect, shear.
MGL code:
subplot 2 2 0:box:text -1 1.1 'Just box' ':L' inplot 0.2 0.5 0.7 1 off:box:text 0 1.2 'InPlot example' subplot 2 2 1:title 'Rotate only':rotate 50 60:box subplot 2 2 2:title 'Rotate and Aspect':rotate 50 60:aspect 1 1 2:box subplot 2 2 3:title 'Shear':box 'c':shear 0.2 0.1:box
C++ code:
void smgl_aspect(mglGraph *gr) // transformation
{
gr->SubPlot(2,2,0); gr->Box();
gr->Puts(mglPoint(-1,1.1),"Just box",":L");
gr->InPlot(0.2,0.5,0.7,1,false); gr->Box();
gr->Puts(mglPoint(0,1.2),"InPlot example");
gr->SubPlot(2,2,1); gr->Title("Rotate only");
gr->Rotate(50,60); gr->Box();
gr->SubPlot(2,2,2); gr->Title("Rotate and Aspect");
gr->Rotate(50,60); gr->Aspect(1,1,2); gr->Box();
gr->SubPlot(2,2,3); gr->Title("Shear");
gr->Box("c"); gr->Shear(0.2,0.1); gr->Box();
}
Next: axis sample, Previous: aspect sample, Up: All samples [Contents][Index]
10.7 Sample ‘axial’
Function axial draw surfaces of rotation for contour lines. You can draw wire surfaces (‘#’ style) or ones rotated in other directions (‘x’, ‘z’ styles).
MGL code:
call 'prepare2d' subplot 2 2 0:title 'Axial plot (default)':light on:alpha on:rotate 50 60:box:axial a subplot 2 2 1:title '"x" style;"." style':light on:rotate 50 60:box:axial a 'x.' subplot 2 2 2:title '"z" style':light on:rotate 50 60:box:axial a 'z' subplot 2 2 3:title '"\#" style':light on:rotate 50 60:box:axial a '#'
C++ code:
void smgl_axial(mglGraph *gr)
{
mglData a; mgls_prepare2d(&a);
if(big!=3) { gr->SubPlot(2,2,0); gr->Title("Axial plot (default)"); }
gr->Light(true); gr->Alpha(true); gr->Rotate(50,60); gr->Box(); gr->Axial(a);
if(big==3) return;
gr->SubPlot(2,2,1); gr->Title("'x' style; '.'style"); gr->Rotate(50,60); gr->Box(); gr->Axial(a,"x.");
gr->SubPlot(2,2,2); gr->Title("'z' style"); gr->Rotate(50,60); gr->Box(); gr->Axial(a,"z");
gr->SubPlot(2,2,3); gr->Title("'\\#' style"); gr->Rotate(50,60); gr->Box(); gr->Axial(a,"#");
}
Next: barh sample, Previous: axial sample, Up: All samples [Contents][Index]
10.8 Sample ‘axis’
Different forms of axis position.
MGL code:
subplot 2 2 0:title 'Axis origin, Grid':origin 0 0:axis:grid:fplot 'x^3'
subplot 2 2 1:title '2 axis':ranges -1 1 -1 1:origin -1 -1:axis:ylabel 'axis_1':fplot 'sin(pi*x)' 'r2'
ranges 0 1 0 1:origin 1 1:axis:ylabel 'axis_2':fplot 'cos(pi*x)'
subplot 2 2 3:title 'More axis':origin nan nan:xrange -1 1:axis:xlabel 'x' 0:ylabel 'y_1' 0:fplot 'x^2' 'k'
yrange -1 1:origin -1.3 -1:axis 'y' 'r':ylabel '#r{y_2}' 0.2:fplot 'x^3' 'r'
subplot 2 2 2:title '4 segments, inverted axis':origin 0 0:
inplot 0.5 1 0.5 1 on:ranges 0 10 0 2:axis
fplot 'sqrt(x/2)':xlabel 'W' 1:ylabel 'U' 1
inplot 0 0.5 0.5 1 on:ranges 1 0 0 2:axis 'x':fplot 'sqrt(x)+x^3':xlabel '\tau' 1
inplot 0.5 1 0 0.5 on:ranges 0 10 4 0:axis 'y':fplot 'x/4':ylabel 'L' -1
inplot 0 0.5 0 0.5 on:ranges 1 0 4 0:fplot '4*x^2'
C++ code:
void smgl_axis(mglGraph *gr)
{
gr->SubPlot(2,2,0); gr->Title("Axis origin, Grid"); gr->SetOrigin(0,0);
gr->Axis(); gr->Grid(); gr->FPlot("x^3");
gr->SubPlot(2,2,1); gr->Title("2 axis");
gr->SetRanges(-1,1,-1,1); gr->SetOrigin(-1,-1,-1); // first axis
gr->Axis(); gr->Label('y',"axis 1",0); gr->FPlot("sin(pi*x)","r2");
gr->SetRanges(0,1,0,1); gr->SetOrigin(1,1,1); // second axis
gr->Axis(); gr->Label('y',"axis 2",0); gr->FPlot("cos(pi*x)");
gr->SubPlot(2,2,3); gr->Title("More axis"); gr->SetOrigin(NAN,NAN); gr->SetRange('x',-1,1);
gr->Axis(); gr->Label('x',"x",0); gr->Label('y',"y_1",0); gr->FPlot("x^2","k");
gr->SetRanges(-1,1,-1,1); gr->SetOrigin(-1.3,-1); // second axis
gr->Axis("y","r"); gr->Label('y',"#r{y_2}",0.2); gr->FPlot("x^3","r");
gr->SubPlot(2,2,2); gr->Title("4 segments, inverted axis"); gr->SetOrigin(0,0);
gr->InPlot(0.5,1,0.5,1); gr->SetRanges(0,10,0,2); gr->Axis();
gr->FPlot("sqrt(x/2)"); gr->Label('x',"W",1); gr->Label('y',"U",1);
gr->InPlot(0,0.5,0.5,1); gr->SetRanges(1,0,0,2); gr->Axis("x");
gr->FPlot("sqrt(x)+x^3"); gr->Label('x',"\\tau",-1);
gr->InPlot(0.5,1,0,0.5); gr->SetRanges(0,10,4,0); gr->Axis("y");
gr->FPlot("x/4"); gr->Label('y',"L",-1);
gr->InPlot(0,0.5,0,0.5); gr->SetRanges(1,0,4,0); gr->FPlot("4*x^2");
}
Next: bars sample, Previous: axis sample, Up: All samples [Contents][Index]
10.9 Sample ‘barh’
Function barh is the similar to bars but draw horizontal bars.
MGL code:
new ys 10 3 '0.8*sin(pi*(x+y/4+1.25))+0.2*rnd':origin 0 0 0 subplot 2 2 0 '':title 'Barh plot (default)':box:barh ys subplot 2 2 1 '':title '2 colors':box:barh ys 'cbgGyr' ranges -3 3 -1 1:subplot 2 2 2 '':title '"a" style':box:barh ys 'a' subplot 2 2 3 '': title '"f" style':box:barh ys 'f'
C++ code:
void smgl_barh(mglGraph *gr)
{
mglData ys(10,3); ys.Modify("0.8*sin(pi*(2*x+y/2))+0.2*rnd");
gr->SetOrigin(0,0,0);
if(big!=3) { gr->SubPlot(2,2,0,""); gr->Title("Barh plot (default)"); }
gr->Box(); gr->Barh(ys);
if(big==3) return;
gr->SubPlot(2,2,1,""); gr->Title("2 colors"); gr->Box(); gr->Barh(ys,"cbgGyr");
gr->SetRanges(-3,3,-1,1); // increase range since summation can exceed [-1,1]
gr->SubPlot(2,2,2,""); gr->Title("'a' style"); gr->Box(); gr->Barh(ys,"a");
gr->SubPlot(2,2,3,""); gr->Title("'f' style"); gr->Box(); gr->Barh(ys,"f");
}
Next: belt sample, Previous: barh sample, Up: All samples [Contents][Index]
10.10 Sample ‘bars’
Function bars draw vertical bars. It have a lot of options: bar-above-bar (‘a’ style), fall like (‘f’ style), 2 colors for positive and negative values, wired bars (‘#’ style), 3D variant.
MGL code:
new ys 10 3 '0.8*sin(pi*(x+y/4+1.25))+0.2*rnd':origin 0 0 0 subplot 3 2 0 '':title 'Bars plot (default)':box:bars ys subplot 3 2 1 '':title '2 colors':box:bars ys 'cbgGyr' subplot 3 2 4 '':title '"\#" style':box:bars ys '#' new yc 30 'sin(pi*x)':new xc 30 'cos(pi*x)':new z 30 'x' subplot 3 2 5:title '3d variant':rotate 50 60:box:bars xc yc z 'r' ranges -1 1 -3 3:subplot 3 2 2 '':title '"a" style':box:bars ys 'a' subplot 3 2 3 '':title '"f" style':box:bars ys 'f'
C++ code:
void smgl_bars(mglGraph *gr)
{
mglData ys(10,3); ys.Modify("0.8*sin(pi*(2*x+y/2))+0.2*rnd");
gr->SetOrigin(0,0,0);
if(big!=3) { gr->SubPlot(3,2,0,""); gr->Title("Bars plot (default)"); }
gr->Box(); gr->Bars(ys);
if(big==3) return;
gr->SubPlot(3,2,1,""); gr->Title("2 colors"); gr->Box(); gr->Bars(ys,"cbgGyr");
gr->SubPlot(3,2,4,""); gr->Title("'\\#' style"); gr->Box(); gr->Bars(ys,"#");
gr->SubPlot(3,2,5); gr->Title("3d variant"); gr->Rotate(50,60); gr->Box();
mglData yc(30), xc(30), z(30); z.Modify("2*x-1");
yc.Modify("sin(pi*(2*x-1))"); xc.Modify("cos(pi*2*x-pi)");
gr->Bars(xc,yc,z,"r");
gr->SetRanges(-1,1,-3,3); // increase range since summation can exceed [-1,1]
gr->SubPlot(3,2,2,""); gr->Title("'a' style"); gr->Box(); gr->Bars(ys,"a");
gr->SubPlot(3,2,3,""); gr->Title("'f' style"); gr->Box(); gr->Bars(ys,"f");
}
Next: bifurcation sample, Previous: bars sample, Up: All samples [Contents][Index]
10.11 Sample ‘belt’
Function belt draw surface by belts. You can use ‘x’ style for drawing lines in other direction.
MGL code:
call 'prepare2d' title 'Belt plot':rotate 50 60:box:belt a
C++ code:
void smgl_belt(mglGraph *gr)
{
mglData a; mgls_prepare2d(&a);
if(big!=3) gr->Title("Belt plot");
gr->Rotate(50,60); gr->Box(); gr->Belt(a);
}
Next: box sample, Previous: belt sample, Up: All samples [Contents][Index]
10.12 Sample ‘bifurcation’
Function bifurcation draw Bifurcation diagram for multiple stationary points of the map (like logistic map).
MGL code:
subplot 1 1 0 '<_':title 'Bifurcation sample' ranges 0 4 0 1:axis bifurcation 0.005 'x*y*(1-y)' 'r'
C++ code:
void smgl_bifurcation(mglGraph *gr)
{
gr->SubPlot(1,1,0,"<_");
if(big!=3) gr->Title("Bifurcation sample");
gr->SetRanges(0,4,0,1); gr->Axis();
gr->Bifurcation(0.005,"x*y*(1-y)","r");
}
Next: boxplot sample, Previous: bifurcation sample, Up: All samples [Contents][Index]
10.13 Sample ‘box’
Different styles of bounding box.
MGL code:
subplot 2 2 0:title 'Box (default)':rotate 50 60:box subplot 2 2 1:title 'colored':rotate 50 60:box 'r' subplot 2 2 2:title 'with faces':rotate 50 60:box '@' subplot 2 2 3:title 'both':rotate 50 60:box '@cm'
C++ code:
void smgl_boxplot(mglGraph *gr) // flow threads and density plot
{
mglData a(10,7); a.Modify("(2*rnd-1)^3/2");
if(big!=3) { gr->SubPlot(1,1,0,""); gr->Title("Boxplot plot"); }
gr->Box(); gr->BoxPlot(a);
}
Next: boxs sample, Previous: box sample, Up: All samples [Contents][Index]
10.14 Sample ‘boxplot’
Function boxplot draw box-and-whisker diagram.
MGL code:
new a 10 7 '(2*rnd-1)^3/2' subplot 1 1 0 '':title 'Boxplot plot':box:boxplot a
C++ code:
void smgl_boxplot(mglGraph *gr) // flow threads and density plot
{
mglData a(10,7); a.Modify("(2*rnd-1)^3/2");
if(big!=3) { gr->SubPlot(1,1,0,""); gr->Title("Boxplot plot"); }
gr->Box(); gr->BoxPlot(a);
}
Next: candle sample, Previous: boxplot sample, Up: All samples [Contents][Index]
10.15 Sample ‘boxs’
Function boxs draw surface by boxes. You can use ‘#’ for drawing wire plot.
MGL code:
call 'prepare2d' origin 0 0 0 subplot 2 2 0:title 'Boxs plot (default)':rotate 40 60:light on:box:boxs a subplot 2 2 1:title '"\@" style':rotate 50 60:box:boxs a '@' subplot 2 2 2:title '"\#" style':rotate 50 60:box:boxs a '#' subplot 2 2 3:title 'compare with Tile':rotate 50 60:box:tile a
C++ code:
void smgl_boxs(mglGraph *gr)
{
mglData a; mgls_prepare2d(&a);
gr->SetOrigin(0,0,0); gr->Light(true);
if(big!=3) {gr->SubPlot(2,2,0); gr->Title("Boxs plot (default)");}
gr->Rotate(40,60); gr->Box(); gr->Boxs(a);
if(big==3) return;
gr->SubPlot(2,2,1); gr->Title("'\\@' style");
gr->Rotate(50,60); gr->Box(); gr->Boxs(a,"@");
gr->SubPlot(2,2,2); gr->Title("'\\#' style");
gr->Rotate(50,60); gr->Box(); gr->Boxs(a,"#");
gr->SubPlot(2,2,3); gr->Title("compare with Tile");
gr->Rotate(50,60); gr->Box(); gr->Tile(a);
}
Next: chart sample, Previous: boxs sample, Up: All samples [Contents][Index]
10.16 Sample ‘candle’
Function candle draw candlestick chart. This is a combination of a line-chart and a bar-chart, in that each bar represents the range of price movement over a given time interval.
MGL code:
new y 30 'sin(pi*x/2)^2' subplot 1 1 0 '':title 'Candle plot (default)' yrange 0 1:box candle y y/2 (y+1)/2
C++ code:
void smgl_candle(mglGraph *gr)
{
mglData y(30); gr->Fill(y,"sin(pi*x/2)^2");
mglData y1(30); gr->Fill(y1,"v/2",y);
mglData y2(30); gr->Fill(y2,"(1+v)/2",y);
if(big!=3) { gr->SubPlot(1,1,0,""); gr->Title("Candle plot (default)"); }
gr->SetRange('y',0,1); gr->Box(); gr->Candle(y,y1,y2);
}
Next: cloud sample, Previous: candle sample, Up: All samples [Contents][Index]
10.17 Sample ‘chart’
Function chart draw colored boxes with width proportional to data values. Use ‘ ’ for empty box. It produce well known pie chart if drawn in polar coordinates.
MGL code:
new ch 7 2 'rnd+0.1':light on subplot 2 2 0:title 'Chart plot (default)':rotate 50 60:box:chart ch subplot 2 2 1:title '"\#" style':rotate 50 60:box:chart ch '#' subplot 2 2 2:title 'Pie chart; " " color':rotate 50 60: axis '(y+1)/2*cos(pi*x)' '(y+1)/2*sin(pi*x)' '':box:chart ch 'bgr cmy#' subplot 2 2 3:title 'Ring chart; " " color':rotate 50 60: axis '(y+2)/3*cos(pi*x)' '(y+2)/3*sin(pi*x)' '':box:chart ch 'bgr cmy#'
C++ code:
void smgl_chart(mglGraph *gr)
{
mglData ch(7,2); for(int i=0;i<7*2;i++) ch.a[i]=mgl_rnd()+0.1;
if(big!=3) { gr->SubPlot(2,2,0); gr->Title("Chart plot (default)"); }
gr->Light(true); gr->Rotate(50,60); gr->Box(); gr->Chart(ch);
if(big==3) return;
gr->SubPlot(2,2,1); gr->Title("'\\#' style");
gr->Rotate(50,60); gr->Box(); gr->Chart(ch,"#");
gr->SubPlot(2,2,2); gr->Title("Pie chart; ' ' color");
gr->SetFunc("(y+1)/2*cos(pi*x)","(y+1)/2*sin(pi*x)","");
gr->Rotate(50,60); gr->Box(); gr->Chart(ch,"bgr cmy#");
gr->SubPlot(2,2,3); gr->Title("Ring chart; ' ' color");
gr->SetFunc("(y+2)/3*cos(pi*x)","(y+2)/3*sin(pi*x)","");
gr->Rotate(50,60); gr->Box(); gr->Chart(ch,"bgr cmy#");
}
Next: colorbar sample, Previous: chart sample, Up: All samples [Contents][Index]
10.18 Sample ‘cloud’
Function cloud draw cloud-like object which is less transparent for higher data values. Similar plot can be created using many (about 10...20 – surf3a a a;value 10) isosurfaces surf3a.
MGL code:
call 'prepare3d' subplot 2 2 0:title 'Cloud plot':rotate 50 60:alpha on:box:cloud c 'wyrRk' subplot 2 2 1:title '"i" style':rotate 50 60:box:cloud c 'iwyrRk' subplot 2 2 2:title '"." style':rotate 50 60:box:cloud c '.wyrRk' subplot 2 2 3:title 'meshnum 10':rotate 50 60:box:cloud c 'wyrRk'; meshnum 10
C++ code:
void smgl_cloud(mglGraph *gr)
{
mglData c; mgls_prepare3d(&c);
if(big!=3) { gr->SubPlot(2,2,0); gr->Title("Cloud plot"); }
gr->Rotate(50,60); gr->Alpha(true);
gr->Box(); gr->Cloud(c,"wyrRk");
if(big==3) return;
gr->SubPlot(2,2,1); gr->Title("'i' style");
gr->Rotate(50,60); gr->Box(); gr->Cloud(c,"iwyrRk");
gr->SubPlot(2,2,2); gr->Title("'.' style");
gr->Rotate(50,60); gr->Box(); gr->Cloud(c,".wyrRk");
gr->SubPlot(2,2,3); gr->Title("meshnum 10");
gr->Rotate(50,60); gr->Box(); gr->Cloud(c,"wyrRk","meshnum 10");
}
Next: combined sample, Previous: cloud sample, Up: All samples [Contents][Index]
10.19 Sample ‘colorbar’
Example of colorbar position and styles.
MGL code:
call 'prepare2d'
new v 9 'x'
subplot 2 2 0:title 'Colorbar out of box':box
colorbar '<':colorbar '>':colorbar '_':colorbar '^'
subplot 2 2 1:title 'Colorbar near box':box
colorbar '<I':colorbar '>I':colorbar '_I':colorbar '^I'
subplot 2 2 2:title 'manual colors':box:contd v a
colorbar v '<':colorbar v '>':colorbar v '_':colorbar v '^'
subplot 2 2 3:title '':text -0.5 1.55 'Color positions' ':C' -2
colorbar 'bwr>' 0.25 0:text -0.9 1.2 'Default'
colorbar 'b{w,0.3}r>' 0.5 0:text -0.1 1.2 'Manual'
crange 0.01 1e3
colorbar '>' 0.75 0:text 0.65 1.2 'Normal scale':colorbar '>':text 1.35 1.2 'Log scale'
C++ code:
void smgl_colorbar(mglGraph *gr)
{
gr->SubPlot(2,2,0); gr->Title("Colorbar out of box"); gr->Box();
gr->Colorbar("<"); gr->Colorbar(">"); gr->Colorbar("_"); gr->Colorbar("^");
gr->SubPlot(2,2,1); gr->Title("Colorbar near box"); gr->Box();
gr->Colorbar("<I"); gr->Colorbar(">I"); gr->Colorbar("_I"); gr->Colorbar("^I");
gr->SubPlot(2,2,2); gr->Title("manual colors");
mglData a,v; mgls_prepare2d(&a,0,&v);
gr->Box(); gr->ContD(v,a);
gr->Colorbar(v,"<"); gr->Colorbar(v,">"); gr->Colorbar(v,"_"); gr->Colorbar(v,"^");
gr->SubPlot(2,2,3); gr->Title(" ");
gr->Puts(mglPoint(-0.5,1.55),"Color positions",":C",-2);
gr->Colorbar("bwr>",0.25,0); gr->Puts(mglPoint(-0.9,1.2),"Default");
gr->Colorbar("b{w,0.3}r>",0.5,0); gr->Puts(mglPoint(-0.1,1.2),"Manual");
gr->Puts(mglPoint(1,1.55),"log-scale",":C",-2);
gr->SetRange('c',0.01,1e3);
gr->Colorbar(">",0.75,0); gr->Puts(mglPoint(0.65,1.2),"Normal scale");
gr->SetFunc("","","","lg(c)");
gr->Colorbar(">"); gr->Puts(mglPoint(1.35,1.2),"Log scale");
}
Next: cones sample, Previous: colorbar sample, Up: All samples [Contents][Index]
10.20 Sample ‘combined’
Example of several plots in the same axis.
MGL code:
call 'prepare2v' call 'prepare3d' new v 10:fill v -0.5 1:copy d sqrt(a^2+b^2) subplot 2 2 0:title 'Surf + Cont':rotate 50 60:light on:box:surf a:cont a 'y' subplot 2 2 1 '':title 'Flow + Dens':light off:box:flow a b 'br':dens d subplot 2 2 2:title 'Mesh + Cont':rotate 50 60:box:mesh a:cont a '_' subplot 2 2 3:title 'Surf3 + ContF3':rotate 50 60:light on box:contf3 v c 'z' 0:contf3 v c 'x':contf3 v c cut 0 -1 -1 1 0 1.1 contf3 v c 'z' c.nz-1:surf3 c -0.5
C++ code:
void smgl_combined(mglGraph *gr) // flow threads and density plot
{
mglData a,b,d; mgls_prepare2v(&a,&b); d = a;
for(int i=0;i<a.nx*a.ny;i++) d.a[i] = hypot(a.a[i],b.a[i]);
mglData c; mgls_prepare3d(&c);
mglData v(10); v.Fill(-0.5,1);
gr->SubPlot(2,2,1,""); gr->Title("Flow + Dens");
gr->Flow(a,b,"br"); gr->Dens(d); gr->Box();
gr->SubPlot(2,2,0); gr->Title("Surf + Cont"); gr->Rotate(50,60);
gr->Light(true); gr->Surf(a); gr->Cont(a,"y"); gr->Box();
gr->SubPlot(2,2,2); gr->Title("Mesh + Cont"); gr->Rotate(50,60);
gr->Box(); gr->Mesh(a); gr->Cont(a,"_");
gr->SubPlot(2,2,3); gr->Title("Surf3 + ContF3");gr->Rotate(50,60);
gr->Box(); gr->ContF3(v,c,"z",0); gr->ContF3(v,c,"x"); gr->ContF3(v,c);
gr->SetCutBox(mglPoint(0,-1,-1), mglPoint(1,0,1.1));
gr->ContF3(v,c,"z",c.nz-1); gr->Surf3(-0.5,c);
}
Next: cont sample, Previous: combined sample, Up: All samples [Contents][Index]
10.21 Sample ‘cones’
Function cones is similar to bars but draw cones.
MGL code:
new ys 10 3 '0.8*sin(pi*(x+y/4+1.25))+0.2*rnd' light on:origin 0 0 0 subplot 3 2 0:title 'Cones plot':rotate 50 60:box:cones ys subplot 3 2 1:title '2 colors':rotate 50 60:box:cones ys 'cbgGyr' subplot 3 2 2:title '"\#" style':rotate 50 60:box:cones ys '#' subplot 3 2 3:title '"a" style':rotate 50 60:zrange -2 2:box:cones ys 'a' subplot 3 2 4:title '"t" style':rotate 50 60:box:cones ys 't' subplot 3 2 5:title '"4" style':rotate 50 60:box:cones ys '4'
C++ code:
void smgl_cones(mglGraph *gr)
{
mglData ys(10,3); ys.Modify("0.8*sin(pi*(2*x+y/2))+0.2*rnd");
gr->Light(true); gr->SetOrigin(0,0,0);
if(big!=3) { gr->SubPlot(3,2,0); gr->Title("Cones plot"); }
gr->Rotate(50,60); gr->Box(); gr->Cones(ys);
if(big==3) return;
gr->SubPlot(3,2,1); gr->Title("2 colors");
gr->Rotate(50,60); gr->Box(); gr->Cones(ys,"cbgGyr");
gr->SubPlot(3,2,2); gr->Title("'\\#' style");
gr->Rotate(50,60); gr->Box(); gr->Cones(ys,"#");
gr->SubPlot(3,2,3); gr->Title("'a' style");
gr->SetRange('z',-2,2); // increase range since summation can exceed [-1,1]
gr->Rotate(50,60); gr->Box(); gr->Cones(ys,"a");
gr->SubPlot(3,2,4); gr->Title("'t' style");
gr->Rotate(50,60); gr->Box(); gr->Cones(ys,"t");
gr->SubPlot(3,2,5); gr->Title("'4' style");
gr->Rotate(50,60); gr->Box(); gr->Cones(ys,"4");
}
Next: cont3 sample, Previous: cones sample, Up: All samples [Contents][Index]
10.22 Sample ‘cont’
Function cont draw contour lines for surface. You can select automatic (default) or manual levels for contours, print contour labels, draw it on the surface (default) or at plane (as Dens).
MGL code:
call 'prepare2d' list v -0.5 -0.15 0 0.15 0.5 subplot 2 2 0:title 'Cont plot (default)':rotate 50 60:box:cont a subplot 2 2 1:title 'manual levels':rotate 50 60:box:cont v a subplot 2 2 2:title '"\_" and "." styles':rotate 50 60:box:cont a '_':cont a '_.2k' subplot 2 2 3 '':title '"t" style':box:cont a 't'
C++ code:
void smgl_cont3(mglGraph *gr)
{
mglData c; mgls_prepare3d(&c);
if(big!=3) gr->Title("Cont3 sample");
gr->Rotate(50,60); gr->Box();
gr->Cont3(c,"x"); gr->Cont3(c); gr->Cont3(c,"z");
}
Next: cont_xyz sample, Previous: cont sample, Up: All samples [Contents][Index]
10.23 Sample ‘cont3’
Function contf3 draw ordinary contour lines but at slices of 3D data.
MGL code:
call 'prepare3d' title 'Cont3 sample':rotate 50 60:box cont3 c 'x':cont3 c:cont3 c 'z'
C++ code:
void smgl_cont3(mglGraph *gr)
{
mglData c; mgls_prepare3d(&c);
if(big!=3) gr->Title("Cont3 sample");
gr->Rotate(50,60); gr->Box();
gr->Cont3(c,"x"); gr->Cont3(c); gr->Cont3(c,"z");
}
Next: contd sample, Previous: cont3 sample, Up: All samples [Contents][Index]
10.24 Sample ‘cont_xyz’
Functions contz, conty, contx draw contour lines on plane perpendicular to corresponding axis. One of possible application is drawing projections of 3D field.
MGL code:
call 'prepare3d'
title 'Cont[XYZ] sample':rotate 50 60:box
contx {sum c 'x'} '' -1:conty {sum c 'y'} '' 1:contz {sum c 'z'} '' -1
C++ code:
void smgl_cont_xyz(mglGraph *gr)
{
mglData c; mgls_prepare3d(&c);
if(big!=3) gr->Title("Cont[XYZ] sample");
gr->Rotate(50,60); gr->Box(); gr->ContX(c.Sum("x"),"",-1);
gr->ContY(c.Sum("y"),"",1); gr->ContZ(c.Sum("z"),"",-1);
}
Next: contf sample, Previous: cont_xyz sample, Up: All samples [Contents][Index]
10.25 Sample ‘contd’
Function contd is similar to contf but with manual contour colors.
MGL code:
call 'prepare2d' list v -0.5 -0.15 0 0.15 0.5 new a1 30 40 3 '0.6*sin(2*pi*x+pi*(z+1)/2)*sin(3*pi*y+pi*z) + 0.4*cos(3*pi*(x*y)+pi*(z+1)^2/2)' subplot 2 2 0:title 'ContD plot (default)':rotate 50 60:box:contd a subplot 2 2 1:title 'manual levels':rotate 50 60:box:contd v a subplot 2 2 2:title '"\_" style':rotate 50 60:box:contd a '_' subplot 2 2 3:title 'several slices':rotate 50 60:box:contd a1
C++ code:
void smgl_contd(mglGraph *gr)
{
mglData a,v(5),a1(30,40,3); mgls_prepare2d(&a); v.a[0]=-0.5;
v.a[1]=-0.15; v.a[2]=0; v.a[3]=0.15; v.a[4]=0.5;
gr->Fill(a1,"0.6*sin(2*pi*x+pi*(z+1)/2)*sin(3*pi*y+pi*z) + 0.4*cos(3*pi*(x*y)+pi*(z+1)^2/2)");
if(big!=3) { gr->SubPlot(2,2,0); gr->Title("ContD plot (default)"); }
gr->Rotate(50,60); gr->Box(); gr->ContD(a);
if(big==3) return;
gr->SubPlot(2,2,1); gr->Title("manual levels");
gr->Rotate(50,60); gr->Box(); gr->ContD(v,a);
gr->SubPlot(2,2,2); gr->Title("'\\_' style");
gr->Rotate(50,60); gr->Box(); gr->ContD(a,"_");
gr->SubPlot(2,2,3); gr->Title("several slices");
gr->Rotate(50,60); gr->Box(); gr->ContD(a1);
}
Next: contf3 sample, Previous: contd sample, Up: All samples [Contents][Index]
10.26 Sample ‘contf’
Function contf draw filled contours. You can select automatic (default) or manual levels for contours.
MGL code:
call 'prepare2d' list v -0.5 -0.15 0 0.15 0.5 new a1 30 40 3 '0.6*sin(2*pi*x+pi*(z+1)/2)*sin(3*pi*y+pi*z) + 0.4*cos(3*pi*(x*y)+pi*(z+1)^2/2)' subplot 2 2 0:title 'ContF plot (default)':rotate 50 60:box:contf a subplot 2 2 1:title 'manual levels':rotate 50 60:box:contf v a subplot 2 2 2:title '"\_" style':rotate 50 60:box:contf a '_' subplot 2 2 3:title 'several slices':rotate 50 60:box:contf a1
C++ code:
void smgl_contf3(mglGraph *gr)
{
mglData c; mgls_prepare3d(&c);
if(big!=3) gr->Title("ContF3 sample");
gr->Rotate(50,60); gr->Light(true); gr->Box();
gr->ContF3(c,"x"); gr->ContF3(c); gr->ContF3(c,"z");
gr->Cont3(c,"kx"); gr->Cont3(c,"k"); gr->Cont3(c,"kz");
}
Next: contf_xyz sample, Previous: contf sample, Up: All samples [Contents][Index]
10.27 Sample ‘contf3’
Function contf3 draw ordinary filled contours but at slices of 3D data.
MGL code:
call 'prepare3d' title 'Cont3 sample':rotate 50 60:box:light on contf3 c 'x':contf3 c:contf3 c 'z' cont3 c 'xk':cont3 c 'k':cont3 c 'zk'
C++ code:
void smgl_contf3(mglGraph *gr)
{
mglData c; mgls_prepare3d(&c);
if(big!=3) gr->Title("ContF3 sample");
gr->Rotate(50,60); gr->Light(true); gr->Box();
gr->ContF3(c,"x"); gr->ContF3(c); gr->ContF3(c,"z");
gr->Cont3(c,"kx"); gr->Cont3(c,"k"); gr->Cont3(c,"kz");
}
Next: contv sample, Previous: contf3 sample, Up: All samples [Contents][Index]
10.28 Sample ‘contf_xyz’
Functions contfz, contfy, contfx, draw filled contours on plane perpendicular to corresponding axis. One of possible application is drawing projections of 3D field.
MGL code:
call 'prepare3d'
title 'ContF[XYZ] sample':rotate 50 60:box
contfx {sum c 'x'} '' -1:contfy {sum c 'y'} '' 1:contfz {sum c 'z'} '' -1
C++ code:
void smgl_contf_xyz(mglGraph *gr)
{
mglData c; mgls_prepare3d(&c);
if(big!=3) gr->Title("ContF[XYZ] sample");
gr->Rotate(50,60); gr->Box(); gr->ContFX(c.Sum("x"),"",-1);
gr->ContFY(c.Sum("y"),"",1); gr->ContFZ(c.Sum("z"),"",-1);
}
Next: correl sample, Previous: contf_xyz sample, Up: All samples [Contents][Index]
10.29 Sample ‘contv’
Function contv draw vertical cylinders (belts) at contour lines.
MGL code:
call 'prepare2d' list v -0.5 -0.15 0 0.15 0.5 subplot 2 2 0:title 'ContV plot (default)':rotate 50 60:box:contv a subplot 2 2 1:title 'manual levels':rotate 50 60:box:contv v a subplot 2 2 2:title '"\_" style':rotate 50 60:box:contv a '_' subplot 2 2 3:title 'ContV and ContF':rotate 50 60:light on:box contv a:contf a:cont a 'k'
C++ code:
void smgl_contv(mglGraph *gr)
{
mglData a,v(5); mgls_prepare2d(&a); v.a[0]=-0.5;
v.a[1]=-0.15; v.a[2]=0; v.a[3]=0.15; v.a[4]=0.5;
if(big!=3) { gr->SubPlot(2,2,0); gr->Title("ContV plot (default)"); }
gr->Rotate(50,60); gr->Box(); gr->ContV(a);
if(big==3) return;
gr->SubPlot(2,2,1); gr->Title("manual levels");
gr->Rotate(50,60); gr->Box(); gr->ContV(v,a);
gr->SubPlot(2,2,2); gr->Title("'\\_' style");
gr->Rotate(50,60); gr->Box(); gr->ContV(a,"_");
gr->SubPlot(2,2,3); gr->Title("ContV and ContF");
gr->Rotate(50,60); gr->Box(); gr->Light(true);
gr->ContV(a); gr->ContF(a); gr->Cont(a,"k");
}
Next: curvcoor sample, Previous: contv sample, Up: All samples [Contents][Index]
10.30 Sample ‘correl’
Test of correlation function (correl).
MGL code:
new a 100 'exp(-10*x^2)' new b 100 'exp(-10*(x+0.5)^2)' yrange 0 1 subplot 1 2 0 '_':title 'Input fields' plot a:plot b:box:axis correl r a b 'x' norm r 0 1:swap r 'x' # make it human readable subplot 1 2 1 '_':title 'Correlation of a and b' plot r 'r':axis:box line 0.5 0 0.5 1 'B|'
C++ code:
void smgl_correl(mglGraph *gr)
{
mglData a(100),b(100);
gr->Fill(a,"exp(-10*x^2)"); gr->Fill(b,"exp(-10*(x+0.5)^2)");
gr->SetRange('y',0,1);
gr->SubPlot(1,2,0,"_"); gr->Title("Input fields");
gr->Plot(a); gr->Plot(b); gr->Axis(); gr->Box();
mglData r = a.Correl(b,"x");
r.Norm(0,1); r.Swap("x"); // make it human readable
gr->SubPlot(1,2,1,"_"); gr->Title("Correlation of a and b");
gr->Plot(r,"r"); gr->Axis(); gr->Box();
gr->Line(mglPoint(0.5,0),mglPoint(0.5,1),"B|");
}
Next: cut sample, Previous: correl sample, Up: All samples [Contents][Index]
10.31 Sample ‘curvcoor’
Some common curvilinear coordinates.
MGL code:
origin -1 1 -1 subplot 2 2 0:title 'Cartesian':rotate 50 60:fplot '2*t-1' '0.5' '0' '2r':axis:grid axis 'y*sin(pi*x)' 'y*cos(pi*x)' '':subplot 2 2 1:title 'Cylindrical':rotate 50 60:fplot '2*t-1' '0.5' '0' '2r':axis:grid axis '2*y*x' 'y*y - x*x' '':subplot 2 2 2:title 'Parabolic':rotate 50 60:fplot '2*t-1' '0.5' '0' '2r':axis:grid axis 'y*sin(pi*x)' 'y*cos(pi*x)' 'x+z':subplot 2 2 3:title 'Spiral':rotate 50 60:fplot '2*t-1' '0.5' '0' '2r':axis:grid
C++ code:
void smgl_curvcoor(mglGraph *gr) // curvilinear coordinates
{
gr->SetOrigin(-1,1,-1);
gr->SubPlot(2,2,0); gr->Title("Cartesian"); gr->Rotate(50,60);
gr->FPlot("2*t-1","0.5","0","r2");
gr->Axis(); gr->Grid();
gr->SetFunc("y*sin(pi*x)","y*cos(pi*x)",0);
gr->SubPlot(2,2,1); gr->Title("Cylindrical"); gr->Rotate(50,60);
gr->FPlot("2*t-1","0.5","0","r2");
gr->Axis(); gr->Grid();
gr->SetFunc("2*y*x","y*y - x*x",0);
gr->SubPlot(2,2,2); gr->Title("Parabolic"); gr->Rotate(50,60);
gr->FPlot("2*t-1","0.5","0","r2");
gr->Axis(); gr->Grid();
gr->SetFunc("y*sin(pi*x)","y*cos(pi*x)","x+z");
gr->SubPlot(2,2,3); gr->Title("Spiral"); gr->Rotate(50,60);
gr->FPlot("2*t-1","0.5","0","r2");
gr->Axis(); gr->Grid();
gr->SetFunc(0,0,0); // set to default Cartesian
}
Next: dat_diff sample, Previous: curvcoor sample, Up: All samples [Contents][Index]
10.32 Sample ‘cut’
Example of point cutting (cut.
MGL code:
call 'prepare2d' call 'prepare3d' subplot 2 2 0:title 'Cut on (default)':rotate 50 60:light on:box:surf a; zrange -1 0.5 subplot 2 2 1:title 'Cut off':rotate 50 60:box:surf a; zrange -1 0.5; cut off subplot 2 2 2:title 'Cut in box':rotate 50 60:box:alpha on cut 0 -1 -1 1 0 1.1:surf3 c cut 0 0 0 0 0 0 # restore back subplot 2 2 3:title 'Cut by formula':rotate 50 60:box cut '(z>(x+0.5*y-1)^2-1) & (z>(x-0.5*y-1)^2-1)':surf3 c
C++ code:
void smgl_cut(mglGraph *gr) // cutting
{
mglData a,c,v(1); mgls_prepare2d(&a); mgls_prepare3d(&c); v.a[0]=0.5;
gr->SubPlot(2,2,0); gr->Title("Cut on (default)"); gr->Rotate(50,60); gr->Light(true);
gr->Box(); gr->Surf(a,"","zrange -1 0.5");
gr->SubPlot(2,2,1); gr->Title("Cut off"); gr->Rotate(50,60);
gr->Box(); gr->Surf(a,"","zrange -1 0.5; cut off");
gr->SubPlot(2,2,2); gr->Title("Cut in box"); gr->Rotate(50,60);
gr->SetCutBox(mglPoint(0,-1,-1), mglPoint(1,0,1.1));
gr->Alpha(true); gr->Box(); gr->Surf3(c);
gr->SetCutBox(mglPoint(0), mglPoint(0)); // switch it off
gr->SubPlot(2,2,3); gr->Title("Cut by formula"); gr->Rotate(50,60);
gr->CutOff("(z>(x+0.5*y-1)^2-1) & (z>(x-0.5*y-1)^2-1)");
gr->Box(); gr->Surf3(c); gr->CutOff(""); // switch it off
}
Next: dat_extra sample, Previous: cut sample, Up: All samples [Contents][Index]
10.33 Sample ‘dat_diff’
Example of diff and integrate.
MGL code:
ranges 0 1 0 1 0 1:new a 30 40 'x*y'
subplot 2 2 0:title 'a(x,y)':rotate 60 40:surf a:box
subplot 2 2 1:title 'da/dx':rotate 60 40:diff a 'x':surf a:box
subplot 2 2 2:title '\int da/dx dxdy':rotate 60 40:integrate a 'xy':surf a:box
subplot 2 2 3:title '\int {d^2}a/dxdy dx':rotate 60 40:diff2 a 'y':surf a:box
C++ code:
void smgl_dat_diff(mglGraph *gr) // differentiate
{
gr->SetRanges(0,1,0,1,0,1);
mglData a(30,40); a.Modify("x*y");
gr->SubPlot(2,2,0); gr->Title("a(x,y)"); gr->Rotate(60,40);
gr->Surf(a); gr->Box();
gr->SubPlot(2,2,1); gr->Title("da/dx"); gr->Rotate(60,40);
a.Diff("x"); gr->Surf(a); gr->Box();
gr->SubPlot(2,2,2); gr->Title("\\int da/dx dxdy"); gr->Rotate(60,40);
a.Integral("xy"); gr->Surf(a); gr->Box();
gr->SubPlot(2,2,3); gr->Title("\\int {d^2}a/dxdy dx"); gr->Rotate(60,40);
a.Diff2("y"); gr->Surf(a); gr->Box();
}
Next: data1 sample, Previous: dat_diff sample, Up: All samples [Contents][Index]
10.34 Sample ‘dat_extra’
Example of envelop, sew, smooth and resize.
MGL code:
subplot 2 2 0 '':title 'Envelop sample':new d1 1000 'exp(-8*x^2)*sin(10*pi*x)'
axis:plot d1 'b':envelop d1 'x':plot d1 'r'
subplot 2 2 1 '':title 'Smooth sample':ranges 0 1 0 1
new y0 30 '0.4*sin(pi*x) + 0.3*cos(1.5*pi*x) - 0.4*sin(2*pi*x)+0.5*rnd'
copy y1 y0:smooth y1 'x3':plot y1 'r';legend '"3" style'
copy y2 y0:smooth y2 'x5':plot y2 'g';legend '"5" style'
copy y3 y0:smooth y3 'x':plot y3 'b';legend 'default'
plot y0 '{m7}:s';legend 'none'
legend:box
subplot 2 2 2:title 'Sew sample':rotate 50 60:light on:alpha on
new d2 100 100 'mod((y^2-(1-x)^2)/2,0.1)'
box:surf d2 'b':sew d2 'xy' 0.1:surf d2 'r'
subplot 2 2 3:title 'Resize sample (interpolation)'
new x0 10 'rnd':new v0 10 'rnd'
resize x1 x0 100:resize v1 v0 100
plot x0 v0 'b+ ':plot x1 v1 'r-':label x0 v0 '%n'
C++ code:
void smgl_dat_extra(mglGraph *gr) // differentiate
{
gr->SubPlot(2,2,0,""); gr->Title("Envelop sample");
mglData d1(1000); gr->Fill(d1,"exp(-8*x^2)*sin(10*pi*x)");
gr->Axis(); gr->Plot(d1, "b");
d1.Envelop('x'); gr->Plot(d1, "r");
gr->SubPlot(2,2,1,""); gr->Title("Smooth sample");
mglData y0(30),y1,y2,y3;
gr->SetRanges(0,1,0,1);
gr->Fill(y0, "0.4*sin(pi*x) + 0.3*cos(1.5*pi*x) - 0.4*sin(2*pi*x)+0.5*rnd");
y1=y0; y1.Smooth("x3");
y2=y0; y2.Smooth("x5");
y3=y0; y3.Smooth("x");
gr->Plot(y0,"{m7}:s", "legend 'none'"); //gr->AddLegend("none","k");
gr->Plot(y1,"r", "legend ''3' style'");
gr->Plot(y2,"g", "legend ''5' style'");
gr->Plot(y3,"b", "legend 'default'");
gr->Legend(); gr->Box();
gr->SubPlot(2,2,2); gr->Title("Sew sample");
mglData d2(100, 100); gr->Fill(d2, "mod((y^2-(1-x)^2)/2,0.1)");
gr->Rotate(50, 60); gr->Light(true); gr->Alpha(true);
gr->Box(); gr->Surf(d2, "b");
d2.Sew("xy", 0.1); gr->Surf(d2, "r");
gr->SubPlot(2,2,3); gr->Title("Resize sample (interpolation)");
mglData x0(10), v0(10), x1, v1;
gr->Fill(x0,"rnd"); gr->Fill(v0,"rnd");
x1 = x0.Resize(100); v1 = v0.Resize(100);
gr->Plot(x0,v0,"b+ "); gr->Plot(x1,v1,"r-");
gr->Label(x0,v0,"%n");
}
Next: data2 sample, Previous: dat_extra sample, Up: All samples [Contents][Index]
10.35 Sample ‘data1’
MGL code:
new a 40 50 60 'exp(-x^2-4*y^2-16*z^2)' light on:alpha on copy b a:diff b 'x':subplot 5 3 0:call 'splot' copy b a:diff2 b 'x':subplot 5 3 1:call 'splot' copy b a:cumsum b 'x':subplot 5 3 2:call 'splot' copy b a:integrate b 'x':subplot 5 3 3:call 'splot' mirror b 'x':subplot 5 3 4:call 'splot' copy b a:diff b 'y':subplot 5 3 5:call 'splot' copy b a:diff2 b 'y':subplot 5 3 6:call 'splot' copy b a:cumsum b 'y':subplot 5 3 7:call 'splot' copy b a:integrate b 'y':subplot 5 3 8:call 'splot' mirror b 'y':subplot 5 3 9:call 'splot' copy b a:diff b 'z':subplot 5 3 10:call 'splot' copy b a:diff2 b 'z':subplot 5 3 11:call 'splot' copy b a:cumsum b 'z':subplot 5 3 12:call 'splot' copy b a:integrate b 'z':subplot 5 3 13:call 'splot' mirror b 'z':subplot 5 3 14:call 'splot' stop func splot 0 title 'max=',b.max:norm b -1 1 on:rotate 70 60:box:surf3 b return
C++ code:
void smgl_data1(mglGraph *gr) // basic data operations
{
mglData a(40,50,60),b; gr->Fill(a,"exp(-x^2-4*y^2-16*z^2)");
gr->Light(true); gr->Alpha(true);
b.Set(a); b.Diff("x"); gr->SubPlot(5,3,0); splot1(gr,b);
b.Set(a); b.Diff2("x"); gr->SubPlot(5,3,1); splot1(gr,b);
b.Set(a); b.CumSum("x"); gr->SubPlot(5,3,2); splot1(gr,b);
b.Set(a); b.Integral("x");gr->SubPlot(5,3,3); splot1(gr,b);
b.Mirror("x"); gr->SubPlot(5,3,4); splot1(gr,b);
b.Set(a); b.Diff("y"); gr->SubPlot(5,3,5); splot1(gr,b);
b.Set(a); b.Diff2("y"); gr->SubPlot(5,3,6); splot1(gr,b);
b.Set(a); b.CumSum("y"); gr->SubPlot(5,3,7); splot1(gr,b);
b.Set(a); b.Integral("y");gr->SubPlot(5,3,8); splot1(gr,b);
b.Mirror("y"); gr->SubPlot(5,3,9); splot1(gr,b);
b.Set(a); b.Diff("z"); gr->SubPlot(5,3,10);splot1(gr,b);
b.Set(a); b.Diff2("z"); gr->SubPlot(5,3,11);splot1(gr,b);
b.Set(a); b.CumSum("z"); gr->SubPlot(5,3,12);splot1(gr,b);
b.Set(a); b.Integral("z");gr->SubPlot(5,3,13);splot1(gr,b);
b.Mirror("z"); gr->SubPlot(5,3,14);splot1(gr,b);
}
Next: dens sample, Previous: data1 sample, Up: All samples [Contents][Index]
10.36 Sample ‘data2’
MGL code:
new a 40 50 60 'exp(-x^2-4*y^2-16*z^2)' light on:alpha on copy b a:sinfft b 'x':subplot 5 3 0:call 'splot' copy b a:cosfft b 'x':subplot 5 3 1:call 'splot' copy b a:hankel b 'x':subplot 5 3 2:call 'splot' copy b a:swap b 'x':subplot 5 3 3:call 'splot' copy b a:smooth b 'x':subplot 5 3 4:call 'splot' copy b a:sinfft b 'y':subplot 5 3 5:call 'splot' copy b a:cosfft b 'y':subplot 5 3 6:call 'splot' copy b a:hankel b 'y':subplot 5 3 7:call 'splot' copy b a:swap b 'y':subplot 5 3 8:call 'splot' copy b a:smooth b 'y':subplot 5 3 9:call 'splot' copy b a:sinfft b 'z':subplot 5 3 10:call 'splot' copy b a:cosfft b 'z':subplot 5 3 11:call 'splot' copy b a:hankel b 'z':subplot 5 3 12:call 'splot' copy b a:swap b 'z':subplot 5 3 13:call 'splot' copy b a:smooth b 'z':subplot 5 3 14:call 'splot' stop func splot 0 title 'max=',b.max:norm b -1 1 on:rotate 70 60:box surf3 b 0.5:surf3 b -0.5 return
C++ code:
void smgl_data2(mglGraph *gr) // data transforms
{
mglData a(40,50,60),b; gr->Fill(a,"exp(-x^2-4*y^2-16*z^2)");
gr->Light(true); gr->Alpha(true);
b.Set(a); b.SinFFT("x"); gr->SubPlot(5,3,0); splot2(gr,b);
b.Set(a); b.CosFFT("x"); gr->SubPlot(5,3,1); splot2(gr,b);
b.Set(a); b.Hankel("x"); gr->SubPlot(5,3,2); splot2(gr,b);
b.Set(a); b.Swap("x"); gr->SubPlot(5,3,3); splot2(gr,b);
b.Set(a); b.Smooth("x"); gr->SubPlot(5,3,4); splot2(gr,b);
b.Set(a); b.SinFFT("y"); gr->SubPlot(5,3,5); splot2(gr,b);
b.Set(a); b.CosFFT("y"); gr->SubPlot(5,3,6); splot2(gr,b);
b.Set(a); b.Hankel("y"); gr->SubPlot(5,3,7); splot2(gr,b);
b.Set(a); b.Swap("y"); gr->SubPlot(5,3,8); splot2(gr,b);
b.Set(a); b.Smooth("y"); gr->SubPlot(5,3,9); splot2(gr,b);
b.Set(a); b.SinFFT("z"); gr->SubPlot(5,3,10);splot2(gr,b);
b.Set(a); b.CosFFT("z"); gr->SubPlot(5,3,11);splot2(gr,b);
b.Set(a); b.Hankel("z"); gr->SubPlot(5,3,12);splot2(gr,b);
b.Set(a); b.Swap("z"); gr->SubPlot(5,3,13);splot2(gr,b);
b.Set(a); b.Smooth("z"); gr->SubPlot(5,3,14);splot2(gr,b);
}
Next: dens3 sample, Previous: data2 sample, Up: All samples [Contents][Index]
10.37 Sample ‘dens’
Function dens draw density plot (also known as color-map) for surface.
MGL code:
call 'prepare2d' new a1 30 40 3 '0.6*sin(2*pi*x+pi*(z+1)/2)*sin(3*pi*y+pi*z) + 0.4*cos(3*pi*(x*y)+pi*(z+1)^2/2)' subplot 2 2 0 '':title 'Dens plot (default)':box:dens a subplot 2 2 1:title '3d variant':rotate 50 60:box:dens a subplot 2 2 2 '':title '"\#" style; meshnum 10':box:dens a '#'; meshnum 10 subplot 2 2 3:title 'several slices':rotate 50 60:box:dens a1
C++ code:
void smgl_dens3(mglGraph *gr)
{
mglData c; mgls_prepare3d(&c);
if(big!=3) gr->Title("Dens3 sample");
gr->Rotate(50,60); gr->Alpha(true); gr->SetAlphaDef(0.7);
gr->SetOrigin(0,0,0); gr->Axis("_xyz"); gr->Box();
gr->Dens3(c,"x"); gr->Dens3(c); gr->Dens3(c,"z");
}
Next: dens_xyz sample, Previous: dens sample, Up: All samples [Contents][Index]
10.38 Sample ‘dens3’
Function dens3 draw ordinary density plots but at slices of 3D data.
MGL code:
call 'prepare3d' title 'Dens3 sample':rotate 50 60:alpha on:alphadef 0.7 origin 0 0 0:box:axis '_xyz' dens3 c 'x':dens3 c ':y':dens3 c 'z'
C++ code:
void smgl_dens3(mglGraph *gr)
{
mglData c; mgls_prepare3d(&c);
if(big!=3) gr->Title("Dens3 sample");
gr->Rotate(50,60); gr->Alpha(true); gr->SetAlphaDef(0.7);
gr->SetOrigin(0,0,0); gr->Axis("_xyz"); gr->Box();
gr->Dens3(c,"x"); gr->Dens3(c); gr->Dens3(c,"z");
}
Next: detect sample, Previous: dens3 sample, Up: All samples [Contents][Index]
10.39 Sample ‘dens_xyz’
Functions densz, densy, densx draw density plot on plane perpendicular to corresponding axis. One of possible application is drawing projections of 3D field.
MGL code:
call 'prepare3d'
title 'Dens[XYZ] sample':rotate 50 60:box
densx {sum c 'x'} '' -1:densy {sum c 'y'} '' 1:densz {sum c 'z'} '' -1
C++ code:
void smgl_dens_xyz(mglGraph *gr)
{
mglData c; mgls_prepare3d(&c);
if(big!=3) gr->Title("Dens[XYZ] sample");
gr->Rotate(50,60); gr->Box(); gr->DensX(c.Sum("x"),0,-1);
gr->DensY(c.Sum("y"),0,1); gr->DensZ(c.Sum("z"),0,-1);
}
Next: dew sample, Previous: dens_xyz sample, Up: All samples [Contents][Index]
10.40 Sample ‘detect’
Example of curve detect.
MGL code:
subplot 1 1 0 '':title 'Detect sample' new a 200 100 'exp(-30*(y-0.5*sin(pi*x))^2-rnd/10)+exp(-30*(y+0.5*sin(pi*x))^2-rnd/10)+exp(-30*(x+y)^2-rnd/10)' ranges 0 a.nx 0 a.ny:box alpha on:crange a:dens a detect r a 0.1 5 plot r(0) r(1) '.'
C++ code:
void smgl_detect(mglGraph *gr)
{
mglData a(200, 100);
gr->Fill(a,"exp(-30*(y-0.5*sin(pi*x))^2-rnd/10)+exp(-30*(y+0.5*sin(pi*x))^2-rnd/10)+exp(-30*(x+y)^2-rnd/10)");
gr->SubPlot(1,1,0,"");
if(big!=3) gr->Title("Detect sample");
gr->SetRanges(0,a.nx,0,a.ny); gr->SetRange('c',a);
gr->Alpha(true); gr->Box(); gr->Dens(a);
mglData r(a.Detect(0.1,5));
gr->Plot(r.SubData(0), r.SubData(1), ".");
}
Next: diffract sample, Previous: detect sample, Up: All samples [Contents][Index]
10.41 Sample ‘dew’
Function dew is similar to vect but use drops instead of arrows.
MGL code:
call 'prepare2v' subplot 1 1 0 '':title 'Dew plot':light on:box:dew a b
C++ code:
void smgl_dew(mglGraph *gr)
{
mglData a,b; mgls_prepare2v(&a,&b);
if(big!=3) {gr->SubPlot(1,1,0,""); gr->Title("Dew plot");}
gr->Box(); gr->Light(true); gr->Dew(a,b);
}
Next: dilate sample, Previous: dew sample, Up: All samples [Contents][Index]
10.42 Sample ‘diffract’
MGL code:
define n 32 #number of points define m 20 # number of iterations define dt 0.01 # time step new res n m+1 ranges -1 1 0 m*dt 0 1 #tridmat periodic variant new !a n 'i',dt*(n/2)^2/2 copy !b !(1-2*a) new !u n 'exp(-6*x^2)' put res u all 0 for $i 0 m tridmat u a b a u 'xdc' put res u all $i+1 next subplot 2 2 0 '<_':title 'Tridmat, periodic b.c.' axis:box:dens res #fourier variant new k n:fillsample k 'xk' copy !e !exp(-i1*dt*k^2) new !u n 'exp(-6*x^2)' put res u all 0 for $i 0 m fourier u 'x' multo u e fourier u 'ix' put res u all $i+1 next subplot 2 2 1 '<_':title 'Fourier method' axis:box:dens res #tridmat zero variant new !u n 'exp(-6*x^2)' put res u all 0 for $i 0 m tridmat u a b a u 'xd' put res u all $i+1 next subplot 2 2 2 '<_':title 'Tridmat, zero b.c.' axis:box:dens res #diffract exp variant new !u n 'exp(-6*x^2)' define q dt*(n/2)^2/8 # need q<0.4 !!! put res u all 0 for $i 0 m for $j 1 8 # due to smaller dt diffract u 'xe' q next put res u all $i+1 next subplot 2 2 3 '<_':title 'Diffract, exp b.c.' axis:box:dens res
C++ code:
void smgl_diffract(mglGraph *gr)
{
long n=32; // number of points
long m=20; // number of iterations
double dt=0.01; // time step
mglData res(n,m+1);
gr->SetRanges(-1,1, 0,m*dt, 0,1);
// tridmat periodic variant
mglDataC a(n), b(n); a = dual(0,dt*n*n/8);
for(long i=0;i<n;i++) b.a[i] = mreal(1)-mreal(2)*a.a[i];
mglDataC u(n); gr->Fill(u,"exp(-6*x^2)"); res.Put(u,-1,0);
for(long i=0;i<m;i++)
{
u = mglTridMatC(a,b,a,u,"xdc");
res.Put(u,-1,i+1);
}
gr->SubPlot(2,2,0,"<_"); gr->Title("Tridmat, periodic b.c.");
gr->Axis(); gr->Box(); gr->Dens(res);
// fourier variant
mglData k(n); k.FillSample("xk");
mglDataC e(n); for(long i=0;i<n;i++) e.a[i] = exp(-dual(0,dt*k.a[i]*k.a[i]));
gr->Fill(u,"exp(-6*x^2)"); res.Put(u,-1,0);
for(long i=0;i<m;i++)
{
u.FFT("x"); u *= e; u.FFT("ix");
res.Put(u,-1,i+1);
}
gr->SubPlot(2,2,1,"<_"); gr->Title("Fourier method");
gr->Axis(); gr->Box(); gr->Dens(res);
// tridmat zero variant
gr->Fill(u,"exp(-6*x^2)"); res.Put(u,-1,0);
for(long i=0;i<m;i++)
{
u = mglTridMatC(a,b,a,u,"xd");
res.Put(u,-1,i+1);
}
gr->SubPlot(2,2,2,"<_"); gr->Title("Tridmat, zero b.c.");
gr->Axis(); gr->Box(); gr->Dens(res);
// diffract exp variant
gr->Fill(u,"exp(-6*x^2)"); res.Put(u,-1,0);
double q=dt*n*n/4/8; // NOTE: need q<0.4 !!!
for(long i=0;i<m;i++)
{
for(long j=0;j<8;j++) // due to smaller dt
u.Diffraction("xe",q);
res.Put(u,-1,i+1);
}
gr->SubPlot(2,2,3,"<_"); gr->Title("Diffract, exp b.c.");
gr->Axis(); gr->Box(); gr->Dens(res);
}
Next: dots sample, Previous: diffract sample, Up: All samples [Contents][Index]
10.43 Sample ‘dilate’
MGL code:
subplot 2 2 0:title 'Dilate&Erode 1D sample' new y 11:put y 1 5 ranges 0 10 0 1:axis:box plot y 'b*' dilate y 0.5 2 plot y 'rs' erode y 0.5 1 plot y 'g#o' subplot 2 2 1:title 'Dilate&Erode 2D sample':rotate 40 60 ranges 0 10 0 10 0 3 axis:box new z 11 11:put z 3 5 5 boxs z 'b':boxs z 'k#' dilate z 1 2 boxs z 'r':boxs z 'k#' erode z 1 1 boxs 2*z 'g':boxs 2*z 'k#' subplot 2 2 2 text 0.5 0.7 'initial' 'ba';size -2 text 0.5 0.5 'dilate=2' 'ra';size -2 text 0.5 0.3 'erode=1' 'ga';size -2 subplot 2 2 3:title 'Dilate&Erode 3D sample' rotate 60 50:light on:alpha on ranges 0 10 0 10 0 10:crange 0 3 axis:box new a 11 11 11:put a 3 5 5 5 surf3a a a 1.5 'b' dilate a 1 2 surf3a a a 0.5 'r' erode a 1 1 surf3a 2*a 2*a 1 'g'
C++ code:
void smgl_dilate(mglGraph *gr)
{
mglData y(11), z(11,11), a(11,11,11);
y.a[5]=1; z.a[5+11*5]=a.a[5+11*(5+11*5)] = 3;
if(big!=3) { gr->SubPlot(2,2,0); gr->Title("Dilate&Erode 1D sample"); }
else gr->SubPlot(1,1,0,"");
gr->SetRanges(0,10,0,1); gr->Axis(); gr->Box(); gr->Plot(y,"b*");
y.Dilate(1,2); gr->Plot(y,"rs");
y.Erode(1,1); gr->Plot(y,"g#o");
if(big==3) return;
gr->SubPlot(2,2,1); gr->Title("Dilate&Erode 2D sample");
gr->Rotate(40,60); gr->SetRanges(0,10,0,10,0,3);
gr->Axis(); gr->Box(); gr->Boxs(z,"b"); gr->Boxs(z,"k#");
z.Dilate(1,2); gr->Boxs(z,"r"); gr->Boxs(z,"k#");
z.Erode(1,1); z*=2; gr->Boxs(z,"g"); gr->Boxs(z,"k#");
gr->SubPlot(2,2,2);
gr->Puts(0.5,0.7,"initial","ba",-2);
gr->Puts(0.5,0.5,"dilate=2","ra",-2);
gr->Puts(0.5,0.3,"erode=1","ga",-2);
gr->SubPlot(2,2,3); gr->Title("Dilate&Erode 3D sample");
gr->Rotate(60,50); gr->Alpha(true); gr->Light(true);
gr->SetRanges(0,10,0,10,0,10); gr->SetRange('c',0,3);
gr->Axis(); gr->Box(); gr->Surf3A(1.5,a,a,"b");
a.Dilate(1,2); gr->Surf3A(0.5,a,a,"r");
a.Erode(1,1); a*=2; gr->Surf3A(1,a,a,"g");
}
Next: earth sample, Previous: dilate sample, Up: All samples [Contents][Index]
10.44 Sample ‘dots’
Function dots is another way to draw irregular points. Dots use color scheme for coloring (see Color scheme).
MGL code:
new t 2000 'pi*(rnd-0.5)':new f 2000 '2*pi*rnd' copy x 0.9*cos(t)*cos(f):copy y 0.9*cos(t)*sin(f):copy z 0.6*sin(t):copy c cos(2*t) subplot 2 2 0:title 'Dots sample':rotate 50 60 box:dots x y z alpha on subplot 2 2 1:title 'add transparency':rotate 50 60 box:dots x y z c subplot 2 2 2:title 'add colorings':rotate 50 60 box:dots x y z x c subplot 2 2 3:title 'Only coloring':rotate 50 60 box:tens x y z x ' .'
C++ code:
void smgl_dots(mglGraph *gr)
{
int i, n=1000;
mglData x(n),y(n),z(n),c(n);
for(i=0;i<n;i++)
{
double t=M_PI*(mgl_rnd()-0.5), f=2*M_PI*mgl_rnd();
x.a[i] = 0.9*cos(t)*cos(f);
y.a[i] = 0.9*cos(t)*sin(f);
z.a[i] = 0.6*sin(t);
c.a[i] = cos(2*t);
}
if(big!=3) { gr->SubPlot(2,2,0); gr->Title("Dots sample"); }
gr->Rotate(50,60); gr->Box(); gr->Dots(x,y,z);
if(big==3) return;
gr->Alpha(true);
gr->SubPlot(2,2,1); gr->Title("add transparency"); gr->Rotate(50,60); gr->Box(); gr->Dots(x,y,z,c);
gr->SubPlot(2,2,2); gr->Title("add coloring"); gr->Rotate(50,60); gr->Box(); gr->Dots(x,y,z,x,c);
gr->SubPlot(2,2,3); gr->Title("Only coloring"); gr->Rotate(50,60); gr->Box(); gr->Tens(x,y,z,x," .");
}
Next: error sample, Previous: dots sample, Up: All samples [Contents][Index]
10.45 Sample ‘earth’
Example of Earth map by using import.
MGL code:
import dat 'Equirectangular-projection.jpg' 'BbGYw' -1 1 subplot 1 1 0 '<>':title 'Earth in 3D':rotate 40 60 copy phi dat 'pi*x':copy tet dat 'pi*y/2' copy x cos(tet)*cos(phi) copy y cos(tet)*sin(phi) copy z sin(tet) light on surfc x y z dat 'BbGYw' contp [-0.51,-0.51] x y z dat 'y'
C++ code:
void smgl_earth(mglGraph *gr)
{
mglData dat; dat.Import("Equirectangular-projection.jpg","BbGYw",-1,1);
// Calc proper 3d coordinates from projection
mglData phi(dat.nx,dat.ny); phi.Fill(-M_PI,M_PI);
mglData tet(dat.nx,dat.ny); tet.Fill(-M_PI/2,M_PI/2,'y');
mglData x(dat.nx,dat.ny), y(dat.nx,dat.ny), z(dat.nx,dat.ny);
#pragma omp parallel for
for(long i=0;i<dat.nx*dat.ny;i++)
{ x.a[i] = cos(tet.a[i])*cos(phi.a[i]);
y.a[i] = cos(tet.a[i])*sin(phi.a[i]);
z.a[i] = sin(tet.a[i]); }
gr->SubPlot(1,1,0,"<>");
if(big!=3) gr->Title("Earth in 3D");
gr->Rotate(40,60); gr->Light(true);
gr->SurfC(x,y,z,dat,"BbGYw");
mglData vals(1); vals.a[0]=-0.51;
gr->ContP(vals, x,y,z,dat,"y");
}
Next: error2 sample, Previous: earth sample, Up: All samples [Contents][Index]
10.46 Sample ‘error’
Function error draw error boxes around the points. You can draw default boxes or semi-transparent symbol (like marker, see Line styles). Also you can set individual color for each box. See also error2 sample.
MGL code:
call 'prepare1d' new y 50 '0.7*sin(pi*x-pi) + 0.5*cos(3*pi*(x+1)/2) + 0.2*sin(pi*(x+1)/2)' new x0 10 'x + 0.1*rnd-0.05':new ex 10 '0.1':new ey 10 '0.2' new y0 10 '0.7*sin(pi*x-pi) + 0.5*cos(3*pi*(x+1)/2) + 0.2*sin(pi*(x+1)/2) + 0.2*rnd-0.1' subplot 2 2 0 '':title 'Error plot (default)':box:plot y:error x0 y0 ex ey 'k' subplot 2 2 1 '':title '"!" style; no e_x':box:plot y:error x0 y0 ey 'o!rgb' subplot 2 2 2 '':title '"\@" style':alpha on:box:plot y:error x0 y0 ex ey '@'; alpha 0.5 subplot 2 2 3:title '3d variant':rotate 50 60:axis for $1 0 9 errbox 2*rnd-1 2*rnd-1 2*rnd-1 0.2 0.2 0.2 'bo' next
C++ code:
void smgl_error2(mglGraph *gr)
{
mglData x0(10), y0(10), ex(10), ey(10);
for(int i=0;i<10;i++)
{ x0.a[i] = mgl_rnd(); y0.a[i] = mgl_rnd(); ey.a[i] = ex.a[i] = 0.1; }
gr->SetRanges(0,1,0,1); gr->Alpha(true);
gr->SubPlot(4,3,0,""); gr->Box(); gr->Error(x0,y0,ex,ey,"#+@");
gr->SubPlot(4,3,1,""); gr->Box(); gr->Error(x0,y0,ex,ey,"#x@");
gr->SubPlot(4,3,2,""); gr->Box(); gr->Error(x0,y0,ex,ey,"#s@","alpha 0.5");
gr->SubPlot(4,3,3,""); gr->Box(); gr->Error(x0,y0,ex,ey,"s@");
gr->SubPlot(4,3,4,""); gr->Box(); gr->Error(x0,y0,ex,ey,"d@");
gr->SubPlot(4,3,5,""); gr->Box(); gr->Error(x0,y0,ex,ey,"#d@","alpha 0.5");
gr->SubPlot(4,3,6,""); gr->Box(); gr->Error(x0,y0,ex,ey,"+@");
gr->SubPlot(4,3,7,""); gr->Box(); gr->Error(x0,y0,ex,ey,"x@");
gr->SubPlot(4,3,8,""); gr->Box(); gr->Error(x0,y0,ex,ey,"o@");
gr->SubPlot(4,3,9,""); gr->Box(); gr->Error(x0,y0,ex,ey,"#o@","alpha 0.5");
gr->SubPlot(4,3,10,""); gr->Box(); gr->Error(x0,y0,ex,ey,"#.@");
gr->SubPlot(4,3,11,""); gr->Box(); gr->Error(x0,y0,ex,ey);
}
Next: export sample, Previous: error sample, Up: All samples [Contents][Index]
10.47 Sample ‘error2’
Example of error kinds.
MGL code:
new x0 10 'rnd':new ex 10 '0.1' new y0 10 'rnd':new ey 10 '0.1' ranges 0 1 0 1 subplot 4 3 0 '':box:error x0 y0 ex ey '#+@' subplot 4 3 1 '':box:error x0 y0 ex ey '#x@' subplot 4 3 2 '':box:error x0 y0 ex ey '#s@'; alpha 0.5 subplot 4 3 3 '':box:error x0 y0 ex ey 's@' subplot 4 3 4 '':box:error x0 y0 ex ey 'd@' subplot 4 3 5 '':box:error x0 y0 ex ey '#d@'; alpha 0.5 subplot 4 3 6 '':box:error x0 y0 ex ey '+@' subplot 4 3 7 '':box:error x0 y0 ex ey 'x@' subplot 4 3 8 '':box:error x0 y0 ex ey 'o@' subplot 4 3 9 '':box:error x0 y0 ex ey '#o@'; alpha 0.5 subplot 4 3 10 '':box:error x0 y0 ex ey '#.@' subplot 4 3 11 '':box:error x0 y0 ex ey; alpha 0.5
C++ code:
void smgl_error2(mglGraph *gr)
{
mglData x0(10), y0(10), ex(10), ey(10);
for(int i=0;i<10;i++)
{ x0.a[i] = mgl_rnd(); y0.a[i] = mgl_rnd(); ey.a[i] = ex.a[i] = 0.1; }
gr->SetRanges(0,1,0,1); gr->Alpha(true);
gr->SubPlot(4,3,0,""); gr->Box(); gr->Error(x0,y0,ex,ey,"#+@");
gr->SubPlot(4,3,1,""); gr->Box(); gr->Error(x0,y0,ex,ey,"#x@");
gr->SubPlot(4,3,2,""); gr->Box(); gr->Error(x0,y0,ex,ey,"#s@","alpha 0.5");
gr->SubPlot(4,3,3,""); gr->Box(); gr->Error(x0,y0,ex,ey,"s@");
gr->SubPlot(4,3,4,""); gr->Box(); gr->Error(x0,y0,ex,ey,"d@");
gr->SubPlot(4,3,5,""); gr->Box(); gr->Error(x0,y0,ex,ey,"#d@","alpha 0.5");
gr->SubPlot(4,3,6,""); gr->Box(); gr->Error(x0,y0,ex,ey,"+@");
gr->SubPlot(4,3,7,""); gr->Box(); gr->Error(x0,y0,ex,ey,"x@");
gr->SubPlot(4,3,8,""); gr->Box(); gr->Error(x0,y0,ex,ey,"o@");
gr->SubPlot(4,3,9,""); gr->Box(); gr->Error(x0,y0,ex,ey,"#o@","alpha 0.5");
gr->SubPlot(4,3,10,""); gr->Box(); gr->Error(x0,y0,ex,ey,"#.@");
gr->SubPlot(4,3,11,""); gr->Box(); gr->Error(x0,y0,ex,ey);
}
Next: fall sample, Previous: error2 sample, Up: All samples [Contents][Index]
10.48 Sample ‘export’
Example of data export and import.
MGL code:
new a 100 100 'x^2*y':new b 100 100 export a 'test_data.png' 'BbcyrR' -1 1 import b 'test_data.png' 'BbcyrR' -1 1 subplot 2 1 0 '':title 'initial':box:dens a subplot 2 1 1 '':title 'imported':box:dens b
C++ code:
void smgl_export(mglGraph *gr) // basic data operations
{
mglData a(100,100), b; gr->Fill(a,"x^2*y");
a.Export("test_data.png","BbcyrR");
b.Import("test_data.png","BbcyrR",-1,1);
gr->SubPlot(2,1,0,""); gr->Title("initial"); gr->Box(); gr->Dens(a);
gr->SubPlot(2,1,1,""); gr->Title("imported"); gr->Box(); gr->Dens(b);
}
Next: fexport sample, Previous: export sample, Up: All samples [Contents][Index]
10.49 Sample ‘fall’
Function fall draw waterfall surface. You can use meshnum for changing number of lines to be drawn. Also you can use ‘x’ style for drawing lines in other direction.
MGL code:
call 'prepare2d' title 'Fall plot':rotate 50 60:box:fall a
C++ code:
void smgl_fall(mglGraph *gr)
{
mglData a; mgls_prepare2d(&a);
if(big!=3) gr->Title("Fall plot");
gr->Rotate(50,60); gr->Box(); gr->Fall(a);
}
Next: fit sample, Previous: fall sample, Up: All samples [Contents][Index]
10.50 Sample ‘fexport’
Example of write to different file formats.
MGL code:
subplot 3 2 0:define y 0.95
define d 0.3:define x0 0.2:define x1 0.5:define x2 0.6
line x0 1-0*d x1 1-0*d 'k-':text x2 y-0*d 'Solid `-`' ':rL'
line x0 1-1*d x1 1-1*d 'k|':text x2 y-1*d 'Long Dash `|`' ':rL'
line x0 1-2*d x1 1-2*d 'k;':text x2 y-2*d 'Dash 1;`' ':rL'
line x0 1-3*d x1 1-3*d 'k=':text x2 y-3*d 'Small dash `=`' ':rL'
line x0 1-4*d x1 1-4*d 'kj':text x2 y-4*d 'Dash-dot `j`' ':rL'
line x0 1-5*d x1 1-5*d 'ki':text x2 y-5*d 'Small dash-dot `i`' ':rL'
line x0 1-6*d x1 1-6*d 'k:':text x2 y-6*d 'Dots `:`' ':rL'
line x0 1-7*d x1 1-7*d 'k ':text x2 y-7*d 'None ``' ':rL'
define d 0.25:define x0 -0.8:define x1 -1:define x2 -0.05
ball x1 5*d 'k.':text x0 5*d '.' ':rL'
ball x1 4*d 'k+':text x0 4*d '+' ':rL'
ball x1 3*d 'kx':text x0 3*d 'x' ':rL'
ball x1 2*d 'k*':text x0 2*d '*' ':rL'
ball x1 d 'ks':text x0 d 's' ':rL'
ball x1 0 'kd':text x0 0 'd' ':rL'
ball x1 -d 0 'ko':text x0 y-d 'o' ':rL'
ball x1 -2*d 0 'k^':text x0 -2*d '\^' ':rL'
ball x1 -3*d 0 'kv':text x0 -3*d 'v' ':rL'
ball x1 -4*d 0 'k<':text x0 -4*d '<' ':rL'
ball x1 -5*d 0 'k>':text x0 -5*d '>' ':rL'
define x0 -0.3:define x1 -0.5
ball x1 5*d 'k#.':text x0 5*d '\#.' ':rL'
ball x1 4*d 'k#+':text x0 4*d '\#+' ':rL'
ball x1 3*d 'k#x':text x0 3*d '\#x' ':rL'
ball x1 2*d 'k#*':text x0 2*d '\#*' ':rL'
ball x1 d 'k#s':text x0 d '\#s' ':rL'
ball x1 0 'k#d':text x0 0 '\#d' ':rL'
ball x1 -d 0 'k#o':text x0 -d '\#o' ':rL'
ball x1 -2*d 0 'k#^':text x0 -2*d '\#\^' ':rL'
ball x1 -3*d 0 'k#v':text x0 -3*d '\#v' ':rL'
ball x1 -4*d 0 'k#<':text x0 -4*d '\#<' ':rL'
ball x1 -5*d 0 'k#>':text x0 -5*d '\#>' ':rL'
subplot 3 2 1
define a 0.1:define b 0.4:define c 0.5
line a 1 b 1 'k-A':text c 1 'Style `A` or `A\_`' ':rL'
line a 0.8 b 0.8 'k-V':text c 0.8 'Style `V` or `V\_`' ':rL'
line a 0.6 b 0.6 'k-K':text c 0.6 'Style `K` or `K\_`' ':rL'
line a 0.4 b 0.4 'k-I':text c 0.4 'Style `I` or `I\_`' ':rL'
line a 0.2 b 0.2 'k-D':text c 0.2 'Style `D` or `D\_`' ':rL'
line a 0 b 0 'k-S':text c 0 'Style `S` or `S\_`' ':rL'
line a -0.2 b -0.2 'k-O':text c -0.2 'Style `O` or `O\_`' ':rL'
line a -0.4 b -0.4 'k-T':text c -0.4 'Style `T` or `T\_`' ':rL'
line a -0.6 b -0.6 'k-_':text c -0.6 'Style `\_` or none' ':rL'
line a -0.8 b -0.8 'k-AS':text c -0.8 'Style `AS`' ':rL'
line a -1 b -1 'k-_A':text c -1 'Style `\_A`' ':rL'
define a -1:define b -0.7:define c -0.6
line a 1 b 1 'kAA':text c 1 'Style `AA`' ':rL'
line a 0.8 b 0.8 'kVV':text c 0.8 'Style `VV`' ':rL'
line a 0.6 b 0.6 'kKK':text c 0.6 'Style `KK`' ':rL'
line a 0.4 b 0.4 'kII':text c 0.4 'Style `II`' ':rL'
line a 0.2 b 0.2 'kDD':text c 0.2 'Style `DD`' ':rL'
line a 0 b 0 'kSS':text c 0 'Style `SS`' ':rL'
line a -0.2 b -0.2 'kOO':text c -0.2 'Style `OO`' ':rL'
line a -0.4 b -0.4 'kTT':text c -0.4 'Style `TT`' ':rL'
line a -0.6 b -0.6 'k-__':text c -0.6 'Style `\_\_`' ':rL'
line a -0.8 b -0.8 'k-VA':text c -0.8 'Style `VA`' ':rL'
line a -1 b -1 'k-AV':text c -1 'Style `AV`' ':rL'
subplot 3 2 2
#LENUQ
facez -1 -1 0 0.4 0.3 'L#':text -0.8 -0.9 'L' 'w:C' -1.4
facez -0.6 -1 0 0.4 0.3 'E#':text -0.4 -0.9 'E' 'w:C' -1.4
facez -0.2 -1 0 0.4 0.3 'N#':text 0 -0.9 'N' 'w:C' -1.4
facez 0.2 -1 0 0.4 0.3 'U#':text 0.4 -0.9 'U' 'w:C' -1.4
facez 0.6 -1 0 0.4 0.3 'Q#':text 0.8 -0.9 'Q' 'w:C' -1.4
#lenuq
facez -1 -0.7 0 0.4 0.3 'l#':text -0.8 -0.6 'l' 'k:C' -1.4
facez -0.6 -0.7 0 0.4 0.3 'e#':text -0.4 -0.6 'e' 'k:C' -1.4
facez -0.2 -0.7 0 0.4 0.3 'n#':text 0 -0.6 'n' 'k:C' -1.4
facez 0.2 -0.7 0 0.4 0.3 'u#':text 0.4 -0.6 'u' 'k:C' -1.4
facez 0.6 -0.7 0 0.4 0.3 'q#':text 0.8 -0.6 'q' 'k:C' -1.4
#CMYkP
facez -1 -0.4 0 0.4 0.3 'C#':text -0.8 -0.3 'C' 'w:C' -1.4
facez -0.6 -0.4 0 0.4 0.3 'M#':text -0.4 -0.3 'M' 'w:C' -1.4
facez -0.2 -0.4 0 0.4 0.3 'Y#':text 0 -0.3 'Y' 'w:C' -1.4
facez 0.2 -0.4 0 0.4 0.3 'k#':text 0.4 -0.3 'k' 'w:C' -1.4
facez 0.6 -0.4 0 0.4 0.3 'P#':text 0.8 -0.3 'P' 'w:C' -1.4
#cmywp
facez -1 -0.1 0 0.4 0.3 'c#':text -0.8 0 'c' 'k:C' -1.4
facez -0.6 -0.1 0 0.4 0.3 'm#':text -0.4 0 'm' 'k:C' -1.4
facez -0.2 -0.1 0 0.4 0.3 'y#':text 0 0 'y' 'k:C' -1.4
facez 0.2 -0.1 0 0.4 0.3 'w#':text 0.4 0 'w' 'k:C' -1.4
facez 0.6 -0.1 0 0.4 0.3 'p#':text 0.8 0 'p' 'k:C' -1.4
#BGRHW
facez -1 0.2 0 0.4 0.3 'B#':text -0.8 0.3 'B' 'w:C' -1.4
facez -0.6 0.2 0 0.4 0.3 'G#':text -0.4 0.3 'G' 'w:C' -1.4
facez -0.2 0.2 0 0.4 0.3 'R#':text 0 0.3 'R' 'w:C' -1.4
facez 0.2 0.2 0 0.4 0.3 'H#':text 0.4 0.3 'H' 'w:C' -1.4
facez 0.6 0.2 0 0.4 0.3 'W#':text 0.8 0.3 'W' 'w:C' -1.4
#bgrhw
facez -1 0.5 0 0.4 0.3 'b#':text -0.8 0.6 'b' 'k:C' -1.4
facez -0.6 0.5 0 0.4 0.3 'g#':text -0.4 0.6 'g' 'k:C' -1.4
facez -0.2 0.5 0 0.4 0.3 'r#':text 0 0.6 'r' 'k:C' -1.4
facez 0.2 0.5 0 0.4 0.3 'h#':text 0.4 0.6 'h' 'k:C' -1.4
facez 0.6 0.5 0 0.4 0.3 'w#':text 0.8 0.6 'w' 'k:C' -1.4
#brighted
facez -1 0.8 0 0.4 0.3 '{r1}#':text -0.8 0.9 '\{r1\}' 'w:C' -1.4
facez -0.6 0.8 0 0.4 0.3 '{r3}#':text -0.4 0.9 '\{r3\}' 'w:C' -1.4
facez -0.2 0.8 0 0.4 0.3 '{r5}#':text 0 0.9 '\{r5\}' 'k:C' -1.4
facez 0.2 0.8 0 0.4 0.3 '{r7}#':text 0.4 0.9 '\{r7\}' 'k:C' -1.4
facez 0.6 0.8 0 0.4 0.3 '{r9}#':text 0.8 0.9 '\{r9\}' 'k:C' -1.4
# HEX
facez -1 -1.3 0 1 0.3 '{xff9966}#':text -0.5 -1.2 '\{xff9966\}' 'k:C' -1.4
facez 0 -1.3 0 1 0.3 '{x83CAFF}#':text 0.5 -1.2 '\{x83caff\}' 'k:C' -1.4
subplot 3 2 3
for $i 0 9
line -1 0.2*$i-1 1 0.2*$i-1 'r','0'+$i
text 1.05 0.2*$i-1 '0'+$i ':L'
next
subplot 3 2 4:title 'TriPlot sample':rotate 50 60
list tt 0 1 2 | 0 1 3 | 0 2 3 | 1 2 3
list xt -1 1 0 0:list yt -1 -1 1 0:list zt -1 -1 -1 1:light on
triplot tt xt yt zt 'b':triplot tt xt yt zt 'k#'
subplot 3 2 5:new r 4 'i+1':ranges 1 4 1 4
axis:mark r r 's':plot r 'b'
write 'fexport.jpg':#write 'fexport.png'
write 'fexport.bmp':write 'fexport.tga'
write 'fexport.eps':write 'fexport.svg'
write 'fexport.gif':write 'fexport.xyz'
write 'fexport.stl':write 'fexport.off'
write 'fexport.tex':write 'fexport.obj'
write 'fexport.prc':write 'fexport.json'
write 'fexport.mgld'
C++ code:
void smgl_fexport(mglGraph *gr) // test file export
{
all_prims(gr);
gr->WriteJPEG("fexport.jpg");
// gr->WritePNG("fexport.png");
gr->WriteBMP("fexport.bmp");
gr->WriteTGA("fexport.tga");
gr->WriteEPS("fexport.eps");
gr->WriteSVG("fexport.svg");
gr->WriteGIF("fexport.gif");
gr->WriteXYZ("fexport.xyz");
gr->WriteSTL("fexport.stl");
gr->WriteOFF("fexport.off");
gr->WriteTEX("fexport.tex");
gr->WriteOBJ("fexport.obj");
gr->WritePRC("fexport.prc");
gr->WriteJSON("fexport.json");
gr->ExportMGLD("fexport.mgld");
gr->Clf();
gr->ImportMGLD("fexport.mgld");
}
Next: flame2d sample, Previous: fexport sample, Up: All samples [Contents][Index]
10.51 Sample ‘fit’
Example of nonlinear fit.
MGL code:
new dat 100 '0.4*rnd+0.1+sin(2*pi*x)' new in 100 '0.3+sin(2*pi*x)' list ini 1 1 3:fit res dat 'a+b*sin(c*x)' 'abc' ini title 'Fitting sample':yrange -2 2:box:axis:plot dat 'k. ' plot res 'r':plot in 'b' text -0.9 -1.3 'fitted:' 'r:L' putsfit 0 -1.8 'y = ' 'r':text 0 2.2 'initial: y = 0.3+sin(2\pi x)' 'b'
C++ code:
void smgl_fit(mglGraph *gr) // nonlinear fitting
{
mglData dat(100), in(100), res;
gr->Fill(dat,"0.4*rnd+0.1+sin(2*pi*x)");
gr->Fill(in,"0.3+sin(2*pi*x)");
double ini[3] = {1,1,3};
mglData Ini(3,ini);
res = gr->Fit(dat, "a+b*sin(c*x)", "abc", Ini);
if(big!=3) gr->Title("Fitting sample");
gr->SetRange('y',-2,2); gr->Box(); gr->Plot(dat, "k. ");
gr->Axis(); gr->Plot(res, "r"); gr->Plot(in, "b");
gr->Puts(mglPoint(-0.9, -1.3), "fitted:", "r:L");
gr->PutsFit(mglPoint(0, -1.8), "y = ", "r");
gr->Puts(mglPoint(0, 2.2), "initial: y = 0.3+sin(2\\pi x)", "b");
// gr->SetRanges(mglPoint(-1,-1,-1),mglPoint(1,1,1)); gr->SetOrigin(0,0,0);
}
Next: flow sample, Previous: fit sample, Up: All samples [Contents][Index]
10.52 Sample ‘flame2d’
Function flame2d generate points for flame fractals in 2d case.
MGL code:
list A [0.33,0,0,0.33,0,0,0.2] [0.33,0,0,0.33,0.67,0,0.2] [0.33,0,0,0.33,0.33,0.33,0.2]\ [0.33,0,0,0.33,0,0.67,0.2] [0.33,0,0,0.33,0.67,0.67,0.2] new B 2 3 A.ny '0.3' put B 3 0 0 -1 put B 3 0 1 -1 put B 3 0 2 -1 flame2d fx fy A B 1000000 subplot 1 1 0 '<_':title 'Flame2d sample' ranges fx fy:box:axis plot fx fy 'r#o ';size 0.05
C++ code:
void smgl_flame2d(mglGraph *gr)
{
mglData A, B(2,3,5);
A.SetList(35, 0.33,0.,0.,0.33,0.,0.,0.2, 0.33,0.,0.,0.33,0.67,0.,0.2, 0.33,0.,0.,0.33,0.33,0.33,0.2,
0.33,0.,0.,0.33,0.,0.67,0.2, 0.33,0.,0.,0.33,0.67,0.67,0.2);
A.Rearrange(7);
for(long i=0;i<2*3*5;i++) B.a[i] = 0.3;
for(long i=0;i<5;i++) B.a[2*3*i] = B.a[2*3*i+1*2] = B.a[2*3*i+2*2] = 3;
mglData f(mglFlame2d(A,B,1000000));
gr->SubPlot(1,1,0,"<_");
if(big!=3) gr->Title("Flame2d sample");
gr->SetRanges(f.SubData(0), f.SubData(1));
gr->Axis(); gr->Box();
gr->Plot(f.SubData(0), f.SubData(1),"r#o ","size 0.05");
}
Next: flow3 sample, Previous: flame2d sample, Up: All samples [Contents][Index]
10.53 Sample ‘flow’
Function flow is another standard way to visualize vector fields – it draw lines (threads) which is tangent to local vector field direction. MathGL draw threads from edges of bounding box and from central slices. Sometimes it is not most appropriate variant – you may want to use flowp to specify manual position of threads. The color scheme is used for coloring (see Color scheme). At this warm color corresponds to normal flow (like attractor), cold one corresponds to inverse flow (like source).
MGL code:
call 'prepare2v' call 'prepare3v' subplot 2 2 0 '':title 'Flow plot (default)':box:flow a b subplot 2 2 1 '':title '"v" style':box:flow a b 'v' subplot 2 2 2 '':title '"#" and "." styles':box:flow a b '#':flow a b '.2k' subplot 2 2 3:title '3d variant':rotate 50 60:box:flow ex ey ez
C++ code:
void smgl_flow(mglGraph *gr)
{
mglData a,b; mgls_prepare2v(&a,&b);
if(big!=3) {gr->SubPlot(2,2,0,""); gr->Title("Flow plot (default)");}
gr->Box(); gr->Flow(a,b);
if(big==3) return;
gr->SubPlot(2,2,1,""); gr->Title("'v' style");
gr->Box(); gr->Flow(a,b,"v");
gr->SubPlot(2,2,2,""); gr->Title("'\\#' and '.' styles");
gr->Box(); gr->Flow(a,b,"#"); gr->Flow(a,b,".2k");
mglData ex,ey,ez; mgls_prepare3v(&ex,&ey,&ez);
gr->SubPlot(2,2,3); gr->Title("3d variant"); gr->Rotate(50,60);
gr->Box(); gr->Flow(ex,ey,ez);
}
Next: fog sample, Previous: flow sample, Up: All samples [Contents][Index]
10.54 Sample ‘flow3’
Function flow3 draw flow threads, which start from given plane.
MGL code:
call 'prepare3v' subplot 2 2 0:title 'Flow3 plot (default)':rotate 50 60:box flow3 ex ey ez subplot 2 2 1:title '"v" style, from boundary':rotate 50 60:box flow3 ex ey ez 'v' 0 subplot 2 2 2:title '"t" style':rotate 50 60:box flow3 ex ey ez 't' 0 subplot 2 2 3:title 'from \i z planes':rotate 50 60:box flow3 ex ey ez 'z' 0 flow3 ex ey ez 'z' 9
C++ code:
void smgl_flow3(mglGraph *gr)
{
mglData ex,ey,ez; mgls_prepare3v(&ex,&ey,&ez);
if(big!=3) {gr->SubPlot(2,2,0); gr->Title("Flow3 plot (default)");}
gr->Rotate(50,60); gr->Box(); gr->Flow3(ex,ey,ez);
if(big==3) return;
gr->SubPlot(2,2,1); gr->Title("'v' style, from boundary");
gr->Rotate(50,60); gr->Box(); gr->Flow3(ex,ey,ez,"v",0);
gr->SubPlot(2,2,2); gr->Title("'t' style");
gr->Rotate(50,60); gr->Box(); gr->Flow3(ex,ey,ez,"t",0);
gr->SubPlot(2,2,3); gr->Title("from \\i z planes");
gr->Rotate(50,60); gr->Box(); gr->Flow3(ex,ey,ez,"z",0); gr->Flow3(ex,ey,ez,"z",9);
}
Next: fonts sample, Previous: flow3 sample, Up: All samples [Contents][Index]
10.55 Sample ‘fog’
Example of fog.
MGL code:
call 'prepare2d' title 'Fog sample':rotate 50 60:light on:fog 1 box:surf a:cont a 'y'
C++ code:
void smgl_fog(mglGraph *gr)
{
mglData a; mgls_prepare2d(&a);
if(big!=3) gr->Title("Fog sample");
gr->Light(true); gr->Rotate(50,60); gr->Fog(1); gr->Box();
gr->Surf(a); gr->Cont(a,"y");
}
Next: grad sample, Previous: fog sample, Up: All samples [Contents][Index]
10.56 Sample ‘fonts’
Example of font typefaces.
MGL code:
define d 0.25 loadfont 'STIX':text 0 1.1 'default font (STIX)' loadfont 'adventor':text 0 1.1-d 'adventor font' loadfont 'bonum':text 0 1.1-2*d 'bonum font' loadfont 'chorus':text 0 1.1-3*d 'chorus font' loadfont 'cursor':text 0 1.1-4*d 'cursor font' loadfont 'heros':text 0 1.1-5*d 'heros font' loadfont 'heroscn':text 0 1.1-6*d 'heroscn font' loadfont 'pagella':text 0 1.1-7*d 'pagella font' loadfont 'schola':text 0 1.1-8*d 'schola font' loadfont 'termes':text 0 1.1-9*d 'termes font' loadfont ''
C++ code:
void smgl_fonts(mglGraph *gr) // font typefaces
{
double h=1.1, d=0.25;
gr->LoadFont("STIX"); gr->Puts(mglPoint(0,h), "default font (STIX)");
gr->LoadFont("adventor"); gr->Puts(mglPoint(0,h-d), "adventor font");
gr->LoadFont("bonum"); gr->Puts(mglPoint(0,h-2*d), "bonum font");
gr->LoadFont("chorus"); gr->Puts(mglPoint(0,h-3*d), "chorus font");
gr->LoadFont("cursor"); gr->Puts(mglPoint(0,h-4*d), "cursor font");
gr->LoadFont("heros"); gr->Puts(mglPoint(0,h-5*d), "heros font");
gr->LoadFont("heroscn"); gr->Puts(mglPoint(0,h-6*d), "heroscn font");
gr->LoadFont("pagella"); gr->Puts(mglPoint(0,h-7*d), "pagella font");
gr->LoadFont("schola"); gr->Puts(mglPoint(0,h-8*d), "schola font");
gr->LoadFont("termes"); gr->Puts(mglPoint(0,h-9*d), "termes font");
gr->LoadFont("");
}
Next: hist sample, Previous: fonts sample, Up: All samples [Contents][Index]
10.57 Sample ‘grad’
Function grad draw gradient lines for matrix.
MGL code:
call 'prepare2d'
subplot 1 1 0 '':title 'Grad plot':box:grad a:dens a '{u8}w{q8}'
C++ code:
void smgl_grad(mglGraph *gr)
{
mglData a; mgls_prepare2d(&a);
if(big!=3) {gr->SubPlot(1,1,0,""); gr->Title("Grad plot");}
gr->Box(); gr->Grad(a); gr->Dens(a,"{u8}w{q8}");
}
Next: ifs2d sample, Previous: grad sample, Up: All samples [Contents][Index]
10.58 Sample ‘hist’
Example of hist (histogram).
MGL code:
new x 10000 '2*rnd-1':new y 10000 '2*rnd-1':copy z exp(-6*(x^2+y^2))
hist xx x z:norm xx 0 1:hist yy y z:norm yy 0 1
multiplot 3 3 3 2 2 '':ranges -1 1 -1 1 0 1:box:dots x y z 'wyrRk'
multiplot 3 3 0 2 1 '':ranges -1 1 0 1:box:bars xx
multiplot 3 3 5 1 2 '':ranges 0 1 -1 1:box:barh yy
subplot 3 3 2:text 0.5 0.5 'Hist and\n{}MultiPlot\n{}sample' 'a' -3
C++ code:
void smgl_hist(mglGraph *gr)
{
mglData x(10000), y(10000), z(10000); gr->Fill(x,"2*rnd-1"); gr->Fill(y,"2*rnd-1"); gr->Fill(z,"exp(-6*(v^2+w^2))",x,y);
mglData xx=gr->Hist(x,z), yy=gr->Hist(y,z); xx.Norm(0,1); yy.Norm(0,1);
gr->MultiPlot(3,3,3,2,2,""); gr->SetRanges(-1,1,-1,1,0,1); gr->Box(); gr->Dots(x,y,z,"wyrRk");
gr->MultiPlot(3,3,0,2,1,""); gr->SetRanges(-1,1,0,1); gr->Box(); gr->Bars(xx);
gr->MultiPlot(3,3,5,1,2,""); gr->SetRanges(0,1,-1,1); gr->Box(); gr->Barh(yy);
gr->SubPlot(3,3,2); gr->Puts(mglPoint(0.5,0.5),"Hist and\nMultiPlot\nsample","a",-3);
}
Next: ifs3d sample, Previous: hist sample, Up: All samples [Contents][Index]
10.59 Sample ‘ifs2d’
Function ifs2d generate points for fractals using iterated function system in 2d case.
MGL code:
list A [0.33,0,0,0.33,0,0,0.2] [0.33,0,0,0.33,0.67,0,0.2] [0.33,0,0,0.33,0.33,0.33,0.2]\ [0.33,0,0,0.33,0,0.67,0.2] [0.33,0,0,0.33,0.67,0.67,0.2] ifs2d fx fy A 100000 subplot 1 1 0 '<_':title 'IFS 2d sample' ranges fx fy:axis plot fx fy 'r#o ';size 0.05
C++ code:
void smgl_ifs2d(mglGraph *gr)
{
mglData A;
A.SetList(35, 0.33,0.,0.,0.33,0.,0.,0.2, 0.33,0.,0.,0.33,0.67,0.,0.2, 0.33,0.,0.,0.33,0.33,0.33,0.2, 0.33,0.,0.,0.33,0.,0.67,0.2, 0.33,0.,0.,0.33,0.67,0.67,0.2);
A.Rearrange(7);
mglData f(mglIFS2d(A,100000));
gr->SubPlot(1,1,0,"<_");
if(big!=3) gr->Title("IFS 2d sample");
gr->SetRanges(f.SubData(0), f.SubData(1));
gr->Axis(); gr->Plot(f.SubData(0), f.SubData(1),"r#o ","size 0.05");
}
Next: indirect sample, Previous: ifs2d sample, Up: All samples [Contents][Index]
10.60 Sample ‘ifs3d’
Function ifs3d generate points for fractals using iterated function system in 3d case.
MGL code:
list A [0,0,0,0,.18,0,0,0,0,0,0,0,.01] [.85,0,0,0,.85,.1,0,-0.1,0.85,0,1.6,0,.85]\ [.2,-.2,0,.2,.2,0,0,0,0.3,0,0.8,0,.07] [-.2,.2,0,.2,.2,0,0,0,0.3,0,0.8,0,.07] ifs3d f A 100000 title 'IFS 3d sample':rotate 50 60 ranges f(0) f(1) f(2):axis:box dots f(0) f(1) f(2) 'G#o';size 0.05
C++ code:
void smgl_ifs3d(mglGraph *gr)
{
mglData A;
A.SetList(52, 0.,0.,0.,0.,.18,0.,0.,0.,0.,0.,0.,0.,.01, .85,0.,0.,0.,.85,.1,0.,-0.1,0.85,0.,1.6,0.,.85,
.2,-.2,0.,.2,.2,0.,0.,0.,0.3,0.,0.8,0.,.07, -.2,.2,0.,.2,.2,0.,0.,0.,0.3,0.,0.8,0.,.07);
A.Rearrange(13);
mglData f(mglIFS3d(A,100000));
if(big!=3) gr->Title("IFS 3d sample");
gr->SetRanges(f.SubData(0), f.SubData(1), f.SubData(2));
gr->Rotate(50,60); gr->Axis(); gr->Box();
gr->Dots(f.SubData(0), f.SubData(1), f.SubData(2),"G#o","size 0.05");
}
Next: inplot sample, Previous: ifs3d sample, Up: All samples [Contents][Index]
10.61 Sample ‘indirect’
Comparison of subdata vs evaluate/
MGL code:
subplot 1 1 0 '':title 'SubData vs Evaluate' new in 9 'x^3/1.1':plot in 'ko ':box new arg 99 '4*x+4' evaluate e in arg off:plot e 'b.'; legend 'Evaluate' subdata s in arg:plot s 'r.';legend 'SubData' legend 2
C++ code:
void smgl_indirect(mglGraph *gr)
{
gr->SubPlot(1,1,0,""); gr->Title("SubData vs Evaluate");
mglData in(9), arg(99), e, s;
gr->Fill(in,"x^3/1.1"); gr->Fill(arg,"4*x+4");
gr->Plot(in,"ko "); gr->Box();
e = in.Evaluate(arg,false); gr->Plot(e,"b.","legend 'Evaluate'");
s = in.SubData(arg); gr->Plot(s,"r.","legend 'SubData'");
gr->Legend(2);
}
Next: iris sample, Previous: indirect sample, Up: All samples [Contents][Index]
10.62 Sample ‘inplot’
Example of inplot, multiplot, columnplot, gridplot, shearplot, stickplot.
MGL code:
subplot 3 2 0:title 'StickPlot' stickplot 3 0 20 30:box 'r':text 0 0 0 '0' 'r' stickplot 3 1 20 30:box 'g':text 0 0 0 '1' 'g' stickplot 3 2 20 30:box 'b':text 0 9 0 '2' 'b' subplot 3 2 3 '':title 'ColumnPlot' columnplot 3 0:box 'r':text 0 0 '0' 'r' columnplot 3 1:box 'g':text 0 0 '1' 'g' columnplot 3 2:box 'b':text 0 0 '2' 'b' subplot 3 2 4 '':title 'GridPlot' gridplot 2 2 0:box 'r':text 0 0 '0' 'r' gridplot 2 2 1:box 'g':text 0 0 '1' 'g' gridplot 2 2 2:box 'b':text 0 0 '2' 'b' gridplot 2 2 3:box 'm':text 0 0 '3' 'm' subplot 3 2 5 '':title 'InPlot':box inplot 0.4 1 0.6 1 on:box 'r' multiplot 3 2 1 2 1 '':title 'MultiPlot and ShearPlot':box shearplot 3 0 0.2 0.1:box 'r':text 0 0 '0' 'r' shearplot 3 1 0.2 0.1:box 'g':text 0 0 '1' 'g' shearplot 3 2 0.2 0.1:box 'b':text 0 0 '2' 'b'
C++ code:
void smgl_inplot(mglGraph *gr)
{
gr->SubPlot(3,2,0); gr->Title("StickPlot");
gr->StickPlot(3, 0, 20, 30); gr->Box("r"); gr->Puts(mglPoint(0),"0","r");
gr->StickPlot(3, 1, 20, 30); gr->Box("g"); gr->Puts(mglPoint(0),"1","g");
gr->StickPlot(3, 2, 20, 30); gr->Box("b"); gr->Puts(mglPoint(0),"2","b");
gr->SubPlot(3,2,3,""); gr->Title("ColumnPlot");
gr->ColumnPlot(3, 0); gr->Box("r"); gr->Puts(mglPoint(0),"0","r");
gr->ColumnPlot(3, 1); gr->Box("g"); gr->Puts(mglPoint(0),"1","g");
gr->ColumnPlot(3, 2); gr->Box("b"); gr->Puts(mglPoint(0),"2","b");
gr->SubPlot(3,2,4,""); gr->Title("GridPlot");
gr->GridPlot(2, 2, 0); gr->Box("r"); gr->Puts(mglPoint(0),"0","r");
gr->GridPlot(2, 2, 1); gr->Box("g"); gr->Puts(mglPoint(0),"1","g");
gr->GridPlot(2, 2, 2); gr->Box("b"); gr->Puts(mglPoint(0),"2","b");
gr->GridPlot(2, 2, 3); gr->Box("m"); gr->Puts(mglPoint(0),"3","m");
gr->SubPlot(3,2,5,""); gr->Title("InPlot"); gr->Box();
gr->InPlot(0.4, 1, 0.6, 1, true); gr->Box("r");
gr->MultiPlot(3,2,1, 2, 1,""); gr->Title("MultiPlot and ShearPlot"); gr->Box();
gr->ShearPlot(3, 0, 0.2, 0.1); gr->Box("r"); gr->Puts(mglPoint(0),"0","r");
gr->ShearPlot(3, 1, 0.2, 0.1); gr->Box("g"); gr->Puts(mglPoint(0),"1","g");
gr->ShearPlot(3, 2, 0.2, 0.1); gr->Box("b"); gr->Puts(mglPoint(0),"2","b");
}
Next: label sample, Previous: inplot sample, Up: All samples [Contents][Index]
10.63 Sample ‘iris’
Function iris draw Iris plot for columns of data array.
MGL code:
read a 'iris.dat' crop a 0 4 'x':rearrange a a.nx 50 subplot 1 1 0 '':title 'Iris plot' iris a 'sepal\n length;sepal\n width;petal\n length;petal\n width' '. ';value -1.5;size -2
C++ code:
void smgl_iris(mglGraph *gr)
{
mglData a("iris.dat"); a.Crop(0,4,'x'); a.Rearrange(4,50);
gr->SubPlot(1,1,0,"");
if(big!=3) gr->Title("Iris sample");
gr->Iris(a, "sepal\nlength;sepal\nwidth;petal\nlength;petal\nwidth", ". ", "value -1.5;size -2");
}
Next: lamerey sample, Previous: iris sample, Up: All samples [Contents][Index]
10.64 Sample ‘label’
Function label print text at data points. The string may contain ‘%x’, ‘%y’, ‘%z’ for x-, y-, z-coordinates of points, ‘%n’ for point index.
MGL code:
new ys 10 '0.2*rnd-0.8*sin(pi*x)' subplot 1 1 0 '':title 'Label plot':box:plot ys ' *':label ys 'y=%y'
C++ code:
void smgl_label(mglGraph *gr)
{
mglData ys(10); ys.Modify("0.8*sin(pi*2*x)+0.2*rnd");
if(big!=3) { gr->SubPlot(1,1,0,""); gr->Title("Label plot"); }
gr->Box(); gr->Plot(ys," *"); gr->Label(ys,"y=%y");
}
Next: legend sample, Previous: label sample, Up: All samples [Contents][Index]
10.65 Sample ‘lamerey’
Function lamerey draw Lamerey diagram.
MGL code:
subplot 1 1 0 '<_':title 'Lamerey sample'
axis:xlabel '\i x':ylabel '\bar{\i x} = 2 \i{x}'
fplot 'x' 'k='
fplot '2*x' 'b'
lamerey 0.00097 '2*x' 'rv~';size 2
lamerey -0.00097 '2*x' 'rv~';size 2
C++ code:
void smgl_lamerey(mglGraph *gr)
{
gr->SubPlot(1,1,0,"<_");
if(big!=3) gr->Title("Lamerey sample");
gr->Axis(); gr->Label('x',"\\i x"); gr->Label('y',"\\bar{\\i x} = 2 \\i{x}");
gr->FPlot("x","k="); gr->FPlot("2*x","b");
gr->Lamerey( 0.00097,"2*x","rv~");
gr->Lamerey(-0.00097,"2*x","rv~");
}
Next: light sample, Previous: lamerey sample, Up: All samples [Contents][Index]
10.66 Sample ‘legend’
Example of legend styles.
MGL code:
addlegend 'sin(\pi {x^2})' 'b':addlegend 'sin(\pi x)' 'g*'
addlegend 'sin(\pi \sqrt{x})' 'rd':addlegend 'jsut text' ' ':addlegend 'no indent for this' ''
subplot 2 2 0 '':title 'Legend (default)':box:legend
legend 1 0.5 '^':text 0.49 0.88 'Style "\^"' 'A:L'
legend 3 'A#':text 0.75 0.65 'Absolute position' 'A'
subplot 2 2 2 '':title 'coloring':box:legend 0 'r#':legend 1 'Wb#':legend 2 'ygr#'
subplot 2 2 3 '':title 'manual position':box
legend 0.5 1:text 0.5 0.5 'at x=0.5, y=1' 'a'
legend 1 '#-':text 0.75 0.25 'Horizontal legend' 'a'
C++ code:
void smgl_legend(mglGraph *gr)
{
gr->AddLegend("sin(\\pi {x^2})","b");
gr->AddLegend("sin(\\pi x)","g*");
gr->AddLegend("sin(\\pi \\sqrt{x})","rd");
gr->AddLegend("just text"," ");
gr->AddLegend("no indent for this","");
if(big!=3) {gr->SubPlot(2,2,0,""); gr->Title("Legend (default)");}
gr->Box(); gr->Legend();
if(big==3) return;
gr->Legend(1,0.5,"^"); gr->Puts(0.49, 0.88, "Style '\\^'","A:L");
gr->Legend(3,"A#");
gr->Puts(mglPoint(0.75,0.65),"Absolute position","A");
gr->SubPlot(2,2,2,""); gr->Title("coloring"); gr->Box();
gr->Legend(0,"r#"); gr->Legend(1,"Wb#"); gr->Legend(2,"ygr#");
gr->SubPlot(2,2,3,""); gr->Title("manual position"); gr->Box();
gr->Legend(0.5,1);
gr->Puts(mglPoint(0.5,0.5),"at x=0.5, y=1","a");
gr->Legend(1,"#-");
gr->Puts(mglPoint(0.75,0.25),"Horizontal legend","a");
}
Next: loglog sample, Previous: legend sample, Up: All samples [Contents][Index]
10.67 Sample ‘light’
Example of light with different types.
MGL code:
light on:attachlight on call 'prepare2d' subplot 2 2 0:title 'Default':rotate 50 60:box:surf a line -1 -0.7 1.7 -1 -0.7 0.7 'BA' subplot 2 2 1:title 'Local':rotate 50 60 light 0 1 0 1 -2 -1 -1 line 1 0 1 -1 -1 0 'BAO':box:surf a subplot 2 2 2:title 'no diffuse':rotate 50 60 diffuse 0 line 1 0 1 -1 -1 0 'BAO':box:surf a subplot 2 2 3:title 'diffusive only':rotate 50 60 diffuse 0.5:light 0 1 0 1 -2 -1 -1 'w' 0 line 1 0 1 -1 -1 0 'BAO':box:surf a
C++ code:
void smgl_light(mglGraph *gr) // local light sources
{
mglData a; mgls_prepare2d(&a);
gr->Light(true); gr->AttachLight(true);
if(big==3)
{ gr->Rotate(50,60); gr->Box(); gr->Surf(a); return; }
gr->SubPlot(2,2,0); gr->Title("Default"); gr->Rotate(50,60);
gr->Line(mglPoint(-1,-0.7,1.7),mglPoint(-1,-0.7,0.7),"BA"); gr->Box(); gr->Surf(a);
gr->SubPlot(2,2,1); gr->Title("Local"); gr->Rotate(50,60);
gr->AddLight(0,mglPoint(1,0,1),mglPoint(-2,-1,-1));
gr->Line(mglPoint(1,0,1),mglPoint(-1,-1,0),"BAO"); gr->Box(); gr->Surf(a);
gr->SubPlot(2,2,2); gr->Title("no diffuse"); gr->Rotate(50,60);
gr->SetDiffuse(0);
gr->Line(mglPoint(1,0,1),mglPoint(-1,-1,0),"BAO"); gr->Box(); gr->Surf(a);
gr->SubPlot(2,2,3); gr->Title("diffusive only"); gr->Rotate(50,60);
gr->SetDiffuse(0.5);
gr->AddLight(0,mglPoint(1,0,1),mglPoint(-2,-1,-1),'w',0);
gr->Line(mglPoint(1,0,1),mglPoint(-1,-1,0),"BAO"); gr->Box(); gr->Surf(a);
}
Next: map sample, Previous: light sample, Up: All samples [Contents][Index]
10.68 Sample ‘loglog’
Example of log- and log-log- axis labels.
MGL code:
subplot 2 2 0 '<_':title 'Semi-log axis':ranges 0.01 100 -1 1:axis 'lg(x)' '' ''
axis:grid 'xy' 'g':fplot 'sin(1/x)':xlabel 'x' 0:ylabel 'y = sin 1/x' 0
subplot 2 2 1 '<_':title 'Log-log axis':ranges 0.01 100 0.1 100:axis 'lg(x)' 'lg(y)' ''
axis:grid '!' 'h=':grid:fplot 'sqrt(1+x^2)'
xlabel 'x' 0:ylabel 'y = \sqrt{1+x^2}' 0
subplot 2 2 2 '<_':title 'Minus-log axis':ranges -100 -0.01 -100 -0.1:axis '-lg(-x)' '-lg(-y)' ''
axis:fplot '-sqrt(1+x^2)':xlabel 'x' 0:ylabel 'y = -\sqrt{1+x^2}' 0
subplot 2 2 3 '<_':title 'Log-ticks':ranges 0.01 100 0 100:axis 'sqrt(x)' '' ''
axis:fplot 'x':xlabel 'x' 1:ylabel 'y = x' 0
C++ code:
void smgl_loglog(mglGraph *gr) // log-log axis
{
gr->SubPlot(2,2,0,"<_"); gr->Title("Semi-log axis"); gr->SetRanges(0.01,100,-1,1); gr->SetFunc("lg(x)","");
gr->Axis(); gr->Grid("xy","g"); gr->FPlot("sin(1/x)"); gr->Label('x',"x",0); gr->Label('y', "y = sin 1/x",0);
gr->SubPlot(2,2,1,"<_"); gr->Title("Log-log axis"); gr->SetRanges(0.01,100,0.1,100); gr->SetFunc("lg(x)","lg(y)");
gr->Axis(); gr->Grid("!","h="); gr->Grid(); gr->FPlot("sqrt(1+x^2)"); gr->Label('x',"x",0); gr->Label('y', "y = \\sqrt{1+x^2}",0);
gr->SubPlot(2,2,2,"<_"); gr->Title("Minus-log axis"); gr->SetRanges(-100,-0.01,-100,-0.1); gr->SetFunc("-lg(-x)","-lg(-y)");
gr->Axis(); gr->FPlot("-sqrt(1+x^2)"); gr->Label('x',"x",0); gr->Label('y', "y = -\\sqrt{1+x^2}",0);
gr->SubPlot(2,2,3,"<_"); gr->Title("Log-ticks"); gr->SetRanges(0.1,100,0,100); gr->SetFunc("sqrt(x)","");
gr->Axis(); gr->FPlot("x"); gr->Label('x',"x",1); gr->Label('y', "y = x",0);
}
Next: mark sample, Previous: loglog sample, Up: All samples [Contents][Index]
10.69 Sample ‘map’
Example of map.
MGL code:
new a 50 40 'x':new b 50 40 'y':zrange -2 2:text 0 0 '\to'
subplot 2 1 0:text 0 1.1 '\{x, y\}' '' -2:box:map a b 'brgk'
subplot 2 1 1:text 0 1.1 '\{\frac{x^3+y^3}{2}, \frac{x-y}{2}\}' '' -2
box:fill a '(x^3+y^3)/2':fill b '(x-y)/2':map a b 'brgk'
C++ code:
void smgl_map(mglGraph *gr) // example of mapping
{
mglData a(50, 40), b(50, 40);
gr->Puts(mglPoint(0, 0), "\\to", ":C", -1.4);
gr->SetRanges(-1,1,-1,1,-2,2);
gr->SubPlot(2, 1, 0);
gr->Fill(a,"x"); gr->Fill(b,"y");
gr->Puts(mglPoint(0, 1.1), "\\{x, y\\}", ":C", -2); gr->Box();
gr->Map(a, b, "brgk");
gr->SubPlot(2, 1, 1);
gr->Fill(a,"(x^3+y^3)/2"); gr->Fill(b,"(x-y)/2");
gr->Puts(mglPoint(0, 1.1), "\\{\\frac{x^3+y^3}{2}, \\frac{x-y}{2}\\}", ":C", -2);
gr->Box();
gr->Map(a, b, "brgk");
}
Next: mask sample, Previous: map sample, Up: All samples [Contents][Index]
10.70 Sample ‘mark’
Example of mark.
MGL code:
call 'prepare1d' subplot 1 1 0 '':title 'Mark plot (default)':box:mark y y1 's'
C++ code:
void smgl_mark(mglGraph *gr)
{
mglData y,y1; mgls_prepare1d(&y,&y1);
if(big!=3) { gr->SubPlot(1,1,0,""); gr->Title("Mark plot (default)"); }
gr->Box(); gr->Mark(y,y1,"s");
}
Next: mesh sample, Previous: mark sample, Up: All samples [Contents][Index]
10.71 Sample ‘mask’
Example of mask kinds.
MGL code:
new a 10 10 'x' subplot 5 4 0 '':title '"-" mask':dens a '3-' subplot 5 4 1 '':title '"+" mask':dens a '3+' subplot 5 4 2 '':title '"=" mask':dens a '3=' subplot 5 4 3 '':title '";" mask':dens a '3;' subplot 5 4 4 '':title '";I" mask':dens a '3;I' subplot 5 4 5 '':title '"o" mask':dens a '3o' subplot 5 4 6 '':title '"O" mask':dens a '3O' subplot 5 4 7 '':title '"s" mask':dens a '3s' subplot 5 4 8 '':title '"S" mask':dens a '3S' subplot 5 4 9 '':title '";/" mask':dens a '3;/' subplot 5 4 10 '':title '"~" mask':dens a '3~' subplot 5 4 11 '':title '"<" mask':dens a '3<' subplot 5 4 12 '':title '">" mask':dens a '3>' subplot 5 4 13 '':title '"j" mask':dens a '3j' subplot 5 4 14 '':title '"-;\" mask':dens a '3\;' subplot 5 4 15 '':title '"d" mask':dens a '3d' subplot 5 4 16 '':title '"D" mask':dens a '3D' subplot 5 4 17 '':title '"*" mask':dens a '3*' subplot 5 4 18 '':title '"\^" mask':dens a '3^' subplot 5 4 19 '':title 'manual mask' mask '+' '24242424FF0101FF':dens a '3+'
C++ code:
void smgl_mask(mglGraph *gr)
{
mglData a(10,10); a.Fill(-1,1);
gr->SubPlot(5,4,0,""); gr->Title("'-' mask"); gr->Dens(a,"3-");
gr->SubPlot(5,4,1,""); gr->Title("'+' mask"); gr->Dens(a,"3+");
gr->SubPlot(5,4,2,""); gr->Title("'=' mask"); gr->Dens(a,"3=");
gr->SubPlot(5,4,3,""); gr->Title("';' mask"); gr->Dens(a,"3;");
gr->SubPlot(5,4,4,""); gr->Title("';I' mask"); gr->Dens(a,"3;I");
gr->SubPlot(5,4,5,""); gr->Title("'o' mask"); gr->Dens(a,"3o");
gr->SubPlot(5,4,6,""); gr->Title("'O' mask"); gr->Dens(a,"3O");
gr->SubPlot(5,4,7,""); gr->Title("'s' mask"); gr->Dens(a,"3s");
gr->SubPlot(5,4,8,""); gr->Title("'S' mask"); gr->Dens(a,"3S");
gr->SubPlot(5,4,9,""); gr->Title("';/' mask"); gr->Dens(a,"3;/");
gr->SubPlot(5,4,10,""); gr->Title("'~' mask"); gr->Dens(a,"3~");
gr->SubPlot(5,4,11,""); gr->Title("'<' mask"); gr->Dens(a,"3<");
gr->SubPlot(5,4,12,""); gr->Title("'>' mask"); gr->Dens(a,"3>");
gr->SubPlot(5,4,13,""); gr->Title("'j' mask"); gr->Dens(a,"3j");
gr->SubPlot(5,4,14,""); gr->Title("';\\\\' mask"); gr->Dens(a,"3;\\");
gr->SubPlot(5,4,15,""); gr->Title("'d' mask"); gr->Dens(a,"3d");
gr->SubPlot(5,4,16,""); gr->Title("'D' mask"); gr->Dens(a,"3D");
gr->SubPlot(5,4,17,""); gr->Title("'*' mask"); gr->Dens(a,"3*");
gr->SubPlot(5,4,18,""); gr->Title("'\\^' mask"); gr->Dens(a,"3^");
gr->SubPlot(5,4,19,""); gr->Title("manual mask");
gr->SetMask('+', "24242424FF0101FF"); gr->Dens(a,"3+");
}
Next: mirror sample, Previous: mask sample, Up: All samples [Contents][Index]
10.72 Sample ‘mesh’
Function mesh draw wired surface. You can use meshnum for changing number of lines to be drawn.
MGL code:
call 'prepare2d' title 'Mesh plot':rotate 50 60:box:mesh a
C++ code:
void smgl_mesh(mglGraph *gr)
{
mglData a; mgls_prepare2d(&a);
if(big!=3) gr->Title("Mesh plot");
gr->Rotate(50,60); gr->Box(); gr->Mesh(a);
}
Next: molecule sample, Previous: mesh sample, Up: All samples [Contents][Index]
10.73 Sample ‘mirror’
Example of using options.
MGL code:
new a 31 41 '-pi*x*exp(-(y+1)^2-4*x^2)' subplot 2 2 0:title 'Options for coordinates':alpha on:light on:rotate 40 60:box surf a 'r';yrange 0 1:surf a 'b';yrange 0 -1 subplot 2 2 1:title 'Option "meshnum"':rotate 40 60:box mesh a 'r'; yrange 0 1:mesh a 'b';yrange 0 -1; meshnum 5 subplot 2 2 2:title 'Option "alpha"':rotate 40 60:box surf a 'r';yrange 0 1; alpha 0.7:surf a 'b';yrange 0 -1; alpha 0.3 subplot 2 2 3 '<_':title 'Option "legend"' fplot 'x^3' 'r'; legend 'y = x^3':fplot 'cos(pi*x)' 'b'; legend 'y = cos \pi x' box:axis:legend 2
C++ code:
void smgl_mirror(mglGraph *gr) // flag #
{
mglData a(31,41);
gr->Fill(a,"-pi*x*exp(-(y+1)^2-4*x^2)");
if(big!=3) { gr->SubPlot(2,2,0); gr->Title("Options for coordinates"); }
gr->Alpha(true); gr->Light(true);
gr->Rotate(40,60); gr->Box();
gr->Surf(a,"r","yrange 0 1"); gr->Surf(a,"b","yrange 0 -1");
if(big==3) return;
gr->SubPlot(2,2,1); gr->Title("Option 'meshnum'");
gr->Rotate(40,60); gr->Box();
gr->Mesh(a,"r","yrange 0 1"); gr->Mesh(a,"b","yrange 0 -1; meshnum 5");
gr->SubPlot(2,2,2); gr->Title("Option 'alpha'");
gr->Rotate(40,60); gr->Box();
gr->Surf(a,"r","yrange 0 1; alpha 0.7"); gr->Surf(a,"b","yrange 0 -1; alpha 0.3");
gr->SubPlot(2,2,3,"<_"); gr->Title("Option 'legend'");
gr->FPlot("x^3","r","legend 'y = x^3'"); gr->FPlot("cos(pi*x)","b","legend 'y = cos \\pi x'");
gr->Box(); gr->Axis(); gr->Legend(2,"");
}
Next: ode sample, Previous: mirror sample, Up: All samples [Contents][Index]
10.74 Sample ‘molecule’
Example of drawing molecules.
MGL code:
alpha on:light on
subplot 2 2 0 '':title 'Methane, CH_4':rotate 60 120
sphere 0 0 0 0.25 'k':drop 0 0 0 0 0 1 0.35 'h' 1 2:sphere 0 0 0.7 0.25 'g'
drop 0 0 0 -0.94 0 -0.33 0.35 'h' 1 2:sphere -0.66 0 -0.23 0.25 'g'
drop 0 0 0 0.47 0.82 -0.33 0.35 'h' 1 2:sphere 0.33 0.57 -0.23 0.25 'g'
drop 0 0 0 0.47 -0.82 -0.33 0.35 'h' 1 2:sphere 0.33 -0.57 -0.23 0.25 'g'
subplot 2 2 1 '':title 'Water, H{_2}O':rotate 60 100
sphere 0 0 0 0.25 'r':drop 0 0 0 0.3 0.5 0 0.3 'm' 1 2:sphere 0.3 0.5 0 0.25 'g'
drop 0 0 0 0.3 -0.5 0 0.3 'm' 1 2:sphere 0.3 -0.5 0 0.25 'g'
subplot 2 2 2 '':title 'Oxygen, O_2':rotate 60 120
drop 0 0.5 0 0 -0.3 0 0.3 'm' 1 2:sphere 0 0.5 0 0.25 'r'
drop 0 -0.5 0 0 0.3 0 0.3 'm' 1 2:sphere 0 -0.5 0 0.25 'r'
subplot 2 2 3 '':title 'Ammonia, NH_3':rotate 60 120
sphere 0 0 0 0.25 'b':drop 0 0 0 0.33 0.57 0 0.32 'n' 1 2
sphere 0.33 0.57 0 0.25 'g':drop 0 0 0 0.33 -0.57 0 0.32 'n' 1 2
sphere 0.33 -0.57 0 0.25 'g':drop 0 0 0 -0.65 0 0 0.32 'n' 1 2
sphere -0.65 0 0 0.25 'g'
C++ code:
void smgl_molecule(mglGraph *gr) // example of moleculas
{
gr->VertexColor(false); gr->Compression(false); // per-vertex colors and compression are detrimental to transparency
gr->DoubleSided(false); // we do not get into atoms, while rendering internal surface has negative impact on trasparency
gr->Alpha(true); gr->Light(true);
gr->SubPlot(2,2,0,""); gr->Title("Methane, CH_4");
gr->StartGroup("Methane");
gr->Rotate(60,120);
gr->Sphere(mglPoint(0,0,0),0.25,"k");
gr->Drop(mglPoint(0,0,0),mglPoint(0,0,1),0.35,"h",1,2);
gr->Sphere(mglPoint(0,0,0.7),0.25,"g");
gr->Drop(mglPoint(0,0,0),mglPoint(-0.94,0,-0.33),0.35,"h",1,2);
gr->Sphere(mglPoint(-0.66,0,-0.23),0.25,"g");
gr->Drop(mglPoint(0,0,0),mglPoint(0.47,0.82,-0.33),0.35,"h",1,2);
gr->Sphere(mglPoint(0.33,0.57,-0.23),0.25,"g");
gr->Drop(mglPoint(0,0,0),mglPoint(0.47,-0.82,-0.33),0.35,"h",1,2);
gr->Sphere(mglPoint(0.33,-0.57,-0.23),0.25,"g");
gr->EndGroup();
gr->SubPlot(2,2,1,""); gr->Title("Water, H_{2}O");
gr->StartGroup("Water");
gr->Rotate(60,100);
gr->StartGroup("Water_O");
gr->Sphere(mglPoint(0,0,0),0.25,"r");
gr->EndGroup();
gr->StartGroup("Water_Bond_1");
gr->Drop(mglPoint(0,0,0),mglPoint(0.3,0.5,0),0.3,"m",1,2);
gr->EndGroup();
gr->StartGroup("Water_H_1");
gr->Sphere(mglPoint(0.3,0.5,0),0.25,"g");
gr->EndGroup();
gr->StartGroup("Water_Bond_2");
gr->Drop(mglPoint(0,0,0),mglPoint(0.3,-0.5,0),0.3,"m",1,2);
gr->EndGroup();
gr->StartGroup("Water_H_2");
gr->Sphere(mglPoint(0.3,-0.5,0),0.25,"g");
gr->EndGroup();
gr->EndGroup();
gr->SubPlot(2,2,2,""); gr->Title("Oxygen, O_2");
gr->StartGroup("Oxygen");
gr->Rotate(60,120);
gr->Drop(mglPoint(0,0.5,0),mglPoint(0,-0.3,0),0.3,"m",1,2);
gr->Sphere(mglPoint(0,0.5,0),0.25,"r");
gr->Drop(mglPoint(0,-0.5,0),mglPoint(0,0.3,0),0.3,"m",1,2);
gr->Sphere(mglPoint(0,-0.5,0),0.25,"r");
gr->EndGroup();
gr->SubPlot(2,2,3,""); gr->Title("Ammonia, NH_3");
gr->StartGroup("Ammonia");
gr->Rotate(60,120);
gr->Sphere(mglPoint(0,0,0),0.25,"b");
gr->Drop(mglPoint(0,0,0),mglPoint(0.33,0.57,0),0.32,"n",1,2);
gr->Sphere(mglPoint(0.33,0.57,0),0.25,"g");
gr->Drop(mglPoint(0,0,0),mglPoint(0.33,-0.57,0),0.32,"n",1,2);
gr->Sphere(mglPoint(0.33,-0.57,0),0.25,"g");
gr->Drop(mglPoint(0,0,0),mglPoint(-0.65,0,0),0.32,"n",1,2);
gr->Sphere(mglPoint(-0.65,0,0),0.25,"g");
gr->EndGroup();
gr->DoubleSided( true ); // put back
}
Next: ohlc sample, Previous: molecule sample, Up: All samples [Contents][Index]
10.75 Sample ‘ode’
Example of phase plain created by ode solving, contour lines (cont) and flow threads.
MGL code:
subplot 2 2 0 '<_':title 'Cont':box
axis:xlabel 'x':ylabel '\dot{x}'
new f 100 100 'y^2+2*x^3-x^2-0.5':cont f
subplot 2 2 1 '<_':title 'Flow':box
axis:xlabel 'x':ylabel '\dot{x}'
new fx 100 100 'x-3*x^2'
new fy 100 100 'y'
flow fy fx 'v';value 7
subplot 2 2 2 '<_':title 'ODE':box
axis:xlabel 'x':ylabel '\dot{x}'
for $x -1 1 0.1
ode r 'y;x-3*x^2' 'xy' [$x,0]
plot r(0) r(1)
ode r '-y;-x+3*x^2' 'xy' [$x,0]
plot r(0) r(1)
next
C++ code:
void smgl_ode(mglGraph *gr)
{
gr->SubPlot(2,2,0,"<_"); gr->Title("Cont"); gr->Box();
gr->Axis(); gr->Label('x',"x"); gr->Label('y',"\\dot{x}");
mglData f(100,100); gr->Fill(f,"y^2+2*x^3-x^2-0.5");
gr->Cont(f);
gr->SubPlot(2,2,1,"<_"); gr->Title("Flow"); gr->Box();
gr->Axis(); gr->Label('x',"x"); gr->Label('y',"\\dot{x}");
mglData fx(100,100), fy(100,100); gr->Fill(fx,"x-3*x^2"); gr->Fill(fy,"y");
gr->Flow(fy,fx,"v","value 7");
gr->SubPlot(2,2,2,"<_"); gr->Title("ODE"); gr->Box();
gr->Axis(); gr->Label('x',"x"); gr->Label('y',"\\dot{x}");
for(double x=-1;x<1;x+=0.1)
{
mglData in(2), r; in.a[0]=x;
r = mglODE("y;x-3*x^2","xy",in);
gr->Plot(r.SubData(0), r.SubData(1));
r = mglODE("-y;-x+3*x^2","xy",in);
gr->Plot(r.SubData(0), r.SubData(1));
}
}
Next: param1 sample, Previous: ode sample, Up: All samples [Contents][Index]
10.76 Sample ‘ohlc’
Function ohlc draw Open-High-Low-Close diagram. This diagram show vertical line for between maximal(high) and minimal(low) values, as well as horizontal lines before/after vertical line for initial(open)/final(close) values of some process.
MGL code:
new o 10 '0.5*sin(pi*x)' new c 10 '0.5*sin(pi*(x+2/9))' new l 10 '0.3*rnd-0.8' new h 10 '0.3*rnd+0.5' subplot 1 1 0 '':title 'OHLC plot':box:ohlc o h l c
C++ code:
void smgl_ohlc(mglGraph *gr) // flow threads and density plot
{
mglData o(10), h(10), l(10), c(10);
gr->Fill(o,"0.5*sin(pi*x)"); gr->Fill(c,"0.5*sin(pi*(x+2/9))");
gr->Fill(l,"0.3*rnd-0.8"); gr->Fill(h,"0.3*rnd+0.5");
if(big!=3) { gr->SubPlot(1,1,0,""); gr->Title("OHLC plot"); }
gr->Box(); gr->OHLC(o,h,l,c);
}
Next: param2 sample, Previous: ohlc sample, Up: All samples [Contents][Index]
10.77 Sample ‘param1’
Example of parametric plots for 1D data.
MGL code:
new x 100 'sin(pi*x)' new y 100 'cos(pi*x)' new z 100 'sin(2*pi*x)' new c 100 'cos(2*pi*x)' subplot 4 3 0:rotate 40 60:box:plot x y z subplot 4 3 1:rotate 40 60:box:area x y z subplot 4 3 2:rotate 40 60:box:tens x y z c subplot 4 3 3:rotate 40 60:box:bars x y z subplot 4 3 4:rotate 40 60:box:stem x y z subplot 4 3 5:rotate 40 60:box:textmark x y z c*2 '\alpha' subplot 4 3 6:rotate 40 60:box:tube x y z c/10 subplot 4 3 7:rotate 40 60:box:mark x y z c 's' subplot 4 3 8:box:error x y z/10 c/10 subplot 4 3 9:rotate 40 60:box:step x y z subplot 4 3 10:rotate 40 60:box:torus x z 'z';light on subplot 4 3 11:rotate 40 60:box:label x y z '%z'
C++ code:
void smgl_param1(mglGraph *gr) // 1d parametric plots
{
mglData x(100), y(100), z(100), c(100);
gr->Fill(x,"sin(pi*x)"); gr->Fill(y,"cos(pi*x)");
gr->Fill(z,"sin(2*pi*x)"); gr->Fill(c,"cos(2*pi*x)");
gr->SubPlot(4,3,0); gr->Rotate(40,60); gr->Box(); gr->Plot(x,y,z);
gr->SubPlot(4,3,1); gr->Rotate(40,60); gr->Box(); gr->Area(x,y,z);
gr->SubPlot(4,3,2); gr->Rotate(40,60); gr->Box(); gr->Tens(x,y,z,c);
gr->SubPlot(4,3,3); gr->Rotate(40,60); gr->Box(); gr->Bars(x,y,z);
gr->SubPlot(4,3,4); gr->Rotate(40,60); gr->Box(); gr->Stem(x,y,z);
gr->SubPlot(4,3,5); gr->Rotate(40,60); gr->Box(); gr->TextMark(x,y,z,c*2,"\\alpha");
gr->SubPlot(4,3,6); gr->Rotate(40,60); gr->Box(); gr->Tube(x,y,z,c/10,"","light on");
gr->SubPlot(4,3,7); gr->Rotate(40,60); gr->Box(); gr->Mark(x,y,z,c,"s");
gr->SubPlot(4,3,8); gr->Rotate(40,60); gr->Box(); gr->Error(x,y,z/10,c/10);
gr->SubPlot(4,3,9); gr->Rotate(40,60); gr->Box(); gr->Step(x,y,z);
gr->SubPlot(4,3,10);gr->Rotate(40,60); gr->Box(); gr->Torus(x,z,"z","light on");
gr->SubPlot(4,3,11);gr->Rotate(40,60); gr->Box(); gr->Label(x,y,z,"%z");
}
Next: param3 sample, Previous: param1 sample, Up: All samples [Contents][Index]
10.78 Sample ‘param2’
Example of parametric plots for 2D data.
MGL code:
new x 100 100 'sin(pi*(x+y)/2)*cos(pi*y/2)' new y 100 100 'cos(pi*(x+y)/2)*cos(pi*y/2)' new z 100 100 'sin(pi*y/2)' new c 100 100 'cos(pi*x)' subplot 4 4 0:rotate 40 60:box:surf x y z subplot 4 4 1:rotate 40 60:box:surfc x y z c subplot 4 4 2:rotate 40 60:box:surfa x y z c;alpha 1 subplot 4 4 3:rotate 40 60:box:mesh x y z;meshnum 10 subplot 4 4 4:rotate 40 60:box:tile x y z;meshnum 10 subplot 4 4 5:rotate 40 60:box:tiles x y z c;meshnum 10 subplot 4 4 6:rotate 40 60:box:axial x y z;alpha 0.5;light on subplot 4 4 7:rotate 40 60:box:cont x y z subplot 4 4 8:rotate 40 60:box:contf x y z;light on:contv x y z;light on subplot 4 4 9:rotate 40 60:box:belt x y z 'x';meshnum 10;light on subplot 4 4 10:rotate 40 60:box:dens x y z;alpha 0.5 subplot 4 4 11:rotate 40 60:box fall x y z 'g';meshnum 10:fall x y z 'rx';meshnum 10 subplot 4 4 12:rotate 40 60:box:belt x y z '';meshnum 10;light on subplot 4 4 13:rotate 40 60:box:boxs x y z '';meshnum 10;light on subplot 4 4 14:rotate 40 60:box:boxs x y z '#';meshnum 10;light on subplot 4 4 15:rotate 40 60:box:boxs x y z '@';meshnum 10;light on
C++ code:
void smgl_param2(mglGraph *gr) // 2d parametric plots
{
mglData x(100,100), y(100,100), z(100,100), c(100,100);
gr->Fill(x,"sin(pi*(x+y)/2)*cos(pi*y/2)"); gr->Fill(y,"cos(pi*(x+y)/2)*cos(pi*y/2)");
gr->Fill(z,"sin(pi*y/2)"); gr->Fill(c,"cos(pi*x)");
gr->SubPlot(4,4,0); gr->Rotate(40,60); gr->Box(); gr->Surf(x,y,z);
gr->SubPlot(4,4,1); gr->Rotate(40,60); gr->Box(); gr->SurfC(x,y,z,c);
gr->SubPlot(4,4,2); gr->Rotate(40,60); gr->Box(); gr->SurfA(x,y,z,c,"","alpha 1");
gr->SubPlot(4,4,3); gr->Rotate(40,60); gr->Box(); gr->Mesh(x,y,z,"","meshnum 10");
gr->SubPlot(4,4,4); gr->Rotate(40,60); gr->Box(); gr->Tile(x,y,z,"","meshnum 10");
gr->SubPlot(4,4,5); gr->Rotate(40,60); gr->Box(); gr->TileS(x,y,z,c,"","meshnum 10");
gr->SubPlot(4,4,6); gr->Rotate(40,60); gr->Box(); gr->Axial(x,y,z,"","alpha 0.5;light on");
gr->SubPlot(4,4,7); gr->Rotate(40,60); gr->Box(); gr->Cont(x,y,z);
gr->SubPlot(4,4,8); gr->Rotate(40,60); gr->Box(); gr->ContF(x,y,z,"","light on"); gr->ContV(x,y,z,"","light on");
gr->SubPlot(4,4,9); gr->Rotate(40,60); gr->Box(); gr->Belt(x,y,z,"x","meshnum 10;light on");
gr->SubPlot(4,4,10);gr->Rotate(40,60); gr->Box(); gr->Dens(x,y,z,"","alpha 0.5");
gr->SubPlot(4,4,11);gr->Rotate(40,60); gr->Box();
gr->Fall(x,y,z,"g","meshnum 10"); gr->Fall(x,y,z,"rx","meshnum 10");
gr->SubPlot(4,4,12); gr->Rotate(40,60); gr->Box(); gr->Belt(x,y,z,"","meshnum 10;light on");
gr->SubPlot(4,4,13); gr->Rotate(40,60); gr->Box(); gr->Boxs(x,y,z,"","meshnum 10;light on");
gr->SubPlot(4,4,14); gr->Rotate(40,60); gr->Box(); gr->Boxs(x,y,z,"#","meshnum 10");
gr->SubPlot(4,4,15); gr->Rotate(40,60); gr->Box(); gr->Boxs(x,y,z,"@","meshnum 10;light on");
}
Next: paramv sample, Previous: param2 sample, Up: All samples [Contents][Index]
10.79 Sample ‘param3’
Example of parametric plots for 3D data.
MGL code:
new x 50 50 50 '(x+2)/3*sin(pi*y/2)' new y 50 50 50 '(x+2)/3*cos(pi*y/2)' new z 50 50 50 'z' new c 50 50 50 '-2*(x^2+y^2+z^4-z^2)+0.2' new d 50 50 50 '1-2*tanh(2*(x+y)^2)' alpha on:light on subplot 4 3 0:rotate 40 60:box:surf3 x y z c subplot 4 3 1:rotate 40 60:box:surf3c x y z c d subplot 4 3 2:rotate 40 60:box:surf3a x y z c d subplot 4 3 3:rotate 40 60:box:cloud x y z c subplot 4 3 4:rotate 40 60:box:cont3 x y z c:cont3 x y z c 'x':cont3 x y z c 'z' subplot 4 3 5:rotate 40 60:box:contf3 x y z c:contf3 x y z c 'x':contf3 x y z c 'z' subplot 4 3 6:rotate 40 60:box:dens3 x y z c:dens3 x y z c 'x':dens3 x y z c 'z' subplot 4 3 7:rotate 40 60:box:dots x y z c;meshnum 15 subplot 4 3 8:rotate 40 60:box:densx c '' 0:densy c '' 0:densz c '' 0 subplot 4 3 9:rotate 40 60:box:contx c '' 0:conty c '' 0:contz c '' 0 subplot 4 3 10:rotate 40 60:box:contfx c '' 0:contfy c '' 0:contfz c '' 0
C++ code:
void smgl_param3(mglGraph *gr) // 3d parametric plots
{
mglData x(50,50,50), y(50,50,50), z(50,50,50), c(50,50,50), d(50,50,50);
gr->Fill(x,"(x+2)/3*sin(pi*y/2)"); gr->Fill(y,"(x+2)/3*cos(pi*y/2)"); gr->Fill(z,"z");
gr->Fill(c,"-2*(x^2+y^2+z^4-z^2)+0.2"); gr->Fill(d,"1-2*tanh(2*(x+y)^2)");
gr->Light(true); gr->Alpha(true);
gr->SubPlot(4,3,0); gr->Rotate(40,60); gr->Box(); gr->Surf3(x,y,z,c);
gr->SubPlot(4,3,1); gr->Rotate(40,60); gr->Box(); gr->Surf3C(x,y,z,c,d);
gr->SubPlot(4,3,2); gr->Rotate(40,60); gr->Box(); gr->Surf3A(x,y,z,c,d);
gr->SubPlot(4,3,3); gr->Rotate(40,60); gr->Box(); gr->Cloud(x,y,z,c);
gr->SubPlot(4,3,4); gr->Rotate(40,60); gr->Box(); gr->Cont3(x,y,z,c); gr->Cont3(x,y,z,c,"x"); gr->Cont3(x,y,z,c,"z");
gr->SubPlot(4,3,5); gr->Rotate(40,60); gr->Box(); gr->ContF3(x,y,z,c);gr->ContF3(x,y,z,c,"x");gr->ContF3(x,y,z,c,"z");
gr->SubPlot(4,3,6); gr->Rotate(40,60); gr->Box(); gr->Dens3(x,y,z,c); gr->Dens3(x,y,z,c,"x"); gr->Dens3(x,y,z,c,"z");
gr->SubPlot(4,3,7); gr->Rotate(40,60); gr->Box(); gr->Dots(x,y,z,c,"","meshnum 15");
gr->SubPlot(4,3,8); gr->Rotate(40,60); gr->Box(); gr->DensX(c,"",0); gr->DensY(c,"",0); gr->DensZ(c,"",0);
gr->SubPlot(4,3,9); gr->Rotate(40,60); gr->Box(); gr->ContX(c,"",0); gr->ContY(c,"",0); gr->ContZ(c,"",0);
gr->SubPlot(4,3,10);gr->Rotate(40,60); gr->Box(); gr->ContFX(c,"",0); gr->ContFY(c,"",0); gr->ContFZ(c,"",0);
}
Next: parser sample, Previous: param3 sample, Up: All samples [Contents][Index]
10.80 Sample ‘paramv’
Example of parametric plots for vector fields.
MGL code:
new x 20 20 20 '(x+2)/3*sin(pi*y/2)'
new y 20 20 20 '(x+2)/3*cos(pi*y/2)'
new z 20 20 20 'z+x'
new ex 20 20 20 'x'
new ey 20 20 20 'x^2+y'
new ez 20 20 20 'y^2+z'
new x1 50 50 '(x+2)/3*sin(pi*y/2)'
new y1 50 50 '(x+2)/3*cos(pi*y/2)'
new e1 50 50 'x'
new e2 50 50 'x^2+y'
subplot 3 3 0:rotate 40 60:box:vect x1 y1 e1 e2
subplot 3 3 1:rotate 40 60:box:flow x1 y1 e1 e2
subplot 3 3 2:rotate 40 60:box:pipe x1 y1 e1 e2
subplot 3 3 3:rotate 40 60:box:dew x1 y1 e1 e2
subplot 3 3 4:rotate 40 60:box:vect x y z ex ey ez
subplot 3 3 5:rotate 40 60:box
vect3 x y z ex ey ez:vect3 x y z ex ey ez 'x':vect3 x y z ex ey ez 'z'
grid3 x y z z '{r9}':grid3 x y z z '{g9}x':grid3 x y z z '{b9}z'
subplot 3 3 6:rotate 40 60:box:flow x y z ex ey ez
subplot 3 3 7:rotate 40 60:box:pipe x y z ex ey ez
C++ code:
void smgl_paramv(mglGraph *gr) // parametric plots for vector field
{
mglData x(20,20,20), y(20,20,20), z(20,20,20), ex(20,20,20), ey(20,20,20), ez(20,20,20);
gr->Fill(x,"(x+2)/3*sin(pi*y/2)"); gr->Fill(y,"(x+2)/3*cos(pi*y/2)"); gr->Fill(z,"x+z");
gr->Fill(ex,"x"); gr->Fill(ey,"x^2+y"); gr->Fill(ez,"y^2+z");
mglData x1(20,20), y1(20,20), e1(20,20), e2(20,20);
gr->Fill(x1,"(x+2)/3*sin(pi*y/2)"); gr->Fill(y1,"(x+2)/3*cos(pi*y/2)");
gr->Fill(e1,"x"); gr->Fill(e2,"x^2+y");
gr->SubPlot(3,3,0); gr->Rotate(40,60); gr->Box(); gr->Vect(x1,y1,e1,e2);
gr->SubPlot(3,3,1); gr->Rotate(40,60); gr->Box(); gr->Flow(x1,y1,e1,e2);
gr->SubPlot(3,3,2); gr->Rotate(40,60); gr->Box(); gr->Pipe(x1,y1,e1,e2);
gr->SubPlot(3,3,3); gr->Rotate(40,60); gr->Box(); gr->Dew(x1,y1,e1,e2);
gr->SubPlot(3,3,4); gr->Rotate(40,60); gr->Box(); gr->Vect(x,y,z,ex,ey,ez);
gr->SubPlot(3,3,5); gr->Rotate(40,60); gr->Box();
gr->Vect3(x,y,z,ex,ey,ez); gr->Vect3(x,y,z,ex,ey,ez,"x"); gr->Vect3(x,y,z,ex,ey,ez,"z");
gr->Grid3(x,y,z,z,"{r9}"); gr->Grid3(x,y,z,z,"{g9}x"); gr->Grid3(x,y,z,z,"{b9}z");
gr->SubPlot(3,3,6); gr->Rotate(40,60); gr->Box(); gr->Flow(x,y,z,ex,ey,ez);
gr->SubPlot(3,3,7); gr->Rotate(40,60); gr->Box(); gr->Pipe(x,y,z,ex,ey,ez);
}
Next: pde sample, Previous: paramv sample, Up: All samples [Contents][Index]
10.81 Sample ‘parser’
Basic MGL script.
MGL code:
title 'MGL parser sample' # call function call 'sample' # ordinary for-loop for $0 -1 1 0.1 if $0<0:line 0 0 1 $0 'r':else:line 0 0 1 $0 'g':endif next # if-elseif-else for $i -1 1 0.5 if $i<0 text 1.1 $i '$i' 'b' elseif $i>0 text 1.1 $i '$i' 'r' else text 1.1 $i '$i' endif next # ordinary do-while do defnum $i $i-0.2 line 0 0 $i 1 'b' while $i>0 # do-next-break do defnum $i $i-0.2 if $i<-1 then break line 0 0 $i 1 'm' next # for-while-continue for $i -5 10 text $i/5 1.1 'a'+($i+5) if $i<0 text $i/5-0.06 1.1 '--' 'b' elseif mod($i,2)=0 text $i/5-0.06 1.1 '~' 'r' else # NOTE: 'continue' bypass the 'while'! continue endif # NOTE: 'while' limit the actual number of iterations while $i<5 # nested loops for $i 0 1 0.1 for $j 0 1 0.1 ball $i $j if $j>0.5 then continue ball $i $j 'b+' next next func 'sample' new dat 100 'sin(2*pi*(i/99+1))' plot dat;xrange -1 0 box:axis xlabel 'x':ylabel 'y' return
C++ code:
void smgl_parser(mglGraph *gr) // example of MGL parsing
{ // NOTE: MGL version show much more variants of loops and conditions.
gr->Title("MGL parser sample");
double a[100]; // let a_i = sin(4*pi*x), x=0...1
for(int i=0;i<100;i++)a[i]=sin(2*M_PI*i/99);
mglParse *parser = new mglParse;
// Add MGL variable and set yours data to it.
mglData *d = dynamic_cast<mglData*>(parser->AddVar("dat"));
if(d) d->Set(a,100);
parser->Execute(gr, "plot dat; xrange -1 0\nbox\naxis");
// You may break script at any line do something
// and continue after that.
parser->Execute(gr, "xlabel 'x'\nylabel 'y'\nbox");
// Also you may use cycles or conditions in script.
parser->Execute(gr, "for $0 -1 1 0.1\nif $0<0\n"
"line 0 0 1 $0 'r':else:line 0 0 1 $0 'g'\n"
"endif\nnext");
// You may use for or do-while loops as C/C++ one
double i=1;
do {
char buf[64]; sprintf(buf,"line 0 0 %g 1 'b'",i);
parser->Execute(gr, buf); i=i-0.2;
} while(i>0);
// or as MGL one.
parser->Execute(gr, "for $i -1 1 0.5\n"
"if $i<0\ntext 1.1 $i '$i' 'b'\n"
"elseif $i>0\ntext 1.1 $i '$i' 'r'\n"
"else\ntext 1.1 $i '$i'\nendif\nnext\n");
// There are 'break' and 'continue' commands in MGL too.
// NOTE: 'next' act as "while(1)" in do-while loops.
parser->Execute(gr, "do\ndefnum $i $i-0.2\n"
"if $i<-1 then break\nline 0 0 $i 1 'm'\nnext\n");
// One issue with 'continue' -- it bypass 'while' checking
parser->Execute(gr, "for $i -5 10\ntext $i/5 1.1 'a'+($i+5)\nif $i<0\n"
"text $i/5-0.06 1.1 '--' 'b'\n"
"elseif mod($i,2)=0\ntext $i/5-0.06 1.1 '~' 'r'\n"
"else\ncontinue\nendif\n"
// NOTE: 'while' limit the actual number of iterations in for-loop.
"while $i<5\n");
// Finally, MGL support nested loops too.
parser->Execute(gr, "for $i 0 1 0.1\nfor $j 0 1 0.1\nball $i $j\n"
"if $j>0.5 then continue\nball $i $j 'b+'\nnext\nnext\n");
// Clean up memory.
delete parser;
}
Next: pendelta sample, Previous: parser sample, Up: All samples [Contents][Index]
10.82 Sample ‘pde’
Example of pde solver.
MGL code:
new re 128 'exp(-48*(x+0.7)^2)':new im 128
pde a 'p^2+q^2-x-1+i*0.5*(z+x)*(z>-x)' re im 0.01 30
transpose a
subplot 1 1 0 '<_':title 'PDE solver'
axis:xlabel '\i x':ylabel '\i z'
crange 0 1:dens a 'wyrRk'
fplot '-x' 'k|'
text 0 0.95 'Equation: ik_0\partial_zu + \Delta u + x\cdot u + i \frac{x+z}{2}\cdot u = 0\n{}absorption: (x+z)/2 for x+z>0'
C++ code:
void smgl_pde(mglGraph *gr) // PDE sample
{
mglData a,re(128),im(128);
gr->Fill(re,"exp(-48*(x+0.7)^2)");
a = gr->PDE("p^2+q^2-x-1+i*0.5*(z+x)*(z>-x)", re, im, 0.01, 30);
a.Transpose("yxz");
if(big!=3) {gr->SubPlot(1,1,0,"<_"); gr->Title("PDE solver"); }
gr->SetRange('c',0,1); gr->Dens(a,"wyrRk");
gr->Axis(); gr->Label('x', "\\i x"); gr->Label('y', "\\i z");
gr->FPlot("-x", "k|");
gr->Puts(mglPoint(0, 0.95), "Equation: ik_0\\partial_zu + \\Delta u + x\\cdot u + i \\frac{x+z}{2}\\cdot u = 0\nabsorption: (x+z)/2 for x+z>0");
}
Next: pipe sample, Previous: pde sample, Up: All samples [Contents][Index]
10.83 Sample ‘pendelta’
Example of pendelta for lines and glyphs smoothing.
MGL code:
quality 6 list a 0.25 0.5 1 2 4 for $0 0 4 pendelta a($0) define $1 0.5*$0-1 line -1 $1 1 $1 'r' text 0 $1 'delta=',a($0) next
C++ code:
void smgl_pendelta(mglGraph *gr)
{
double a[5]={0.25,0.5,1,2,4};
gr->SetQuality(6);
char buf[64];
for(int i=0;i<5;i++)
{
gr->SetPenDelta(a[i]);
gr->Line(mglPoint(-1,0.5*i-1), mglPoint(1,0.5*i-1),"r");
sprintf(buf,"delta=%g",a[i]);
gr->Puts(mglPoint(0,0.5*i-1),buf);
}
}
Next: plot sample, Previous: pendelta sample, Up: All samples [Contents][Index]
10.84 Sample ‘pipe’
Function pipe is similar to flow but draw pipes (tubes) which radius is proportional to the amplitude of vector field. The color scheme is used for coloring (see Color scheme). At this warm color corresponds to normal flow (like attractor), cold one corresponds to inverse flow (like source).
MGL code:
call 'prepare2v' call 'prepare3v' subplot 2 2 0 '':title 'Pipe plot (default)':light on:box:pipe a b subplot 2 2 1 '':title '"i" style':box:pipe a b 'i' subplot 2 2 2 '':title 'from edges only':box:pipe a b '#' subplot 2 2 3:title '3d variant':rotate 50 60:box:pipe ex ey ez '' 0.1
C++ code:
void smgl_pipe(mglGraph *gr)
{
mglData a,b; mgls_prepare2v(&a,&b);
if(big!=3) {gr->SubPlot(2,2,0,""); gr->Title("Pipe plot (default)");}
gr->Light(true); gr->Box(); gr->Pipe(a,b);
if(big==3) return;
gr->SubPlot(2,2,1,""); gr->Title("'i' style"); gr->Box(); gr->Pipe(a,b,"i");
gr->SubPlot(2,2,2,""); gr->Title("'\\#' style"); gr->Box(); gr->Pipe(a,b,"#");
mglData ex,ey,ez; mgls_prepare3v(&ex,&ey,&ez);
gr->SubPlot(2,2,3); gr->Title("3d variant"); gr->Rotate(50,60);
gr->Box(); gr->Pipe(ex,ey,ez,"",0.1);
}
Next: pmap sample, Previous: pipe sample, Up: All samples [Contents][Index]
10.85 Sample ‘plot’
Function plot is most standard way to visualize 1D data array. By default, Plot use colors from palette. However, you can specify manual color/palette, and even set to use new color for each points by using ‘!’ style. Another feature is ‘ ’ style which draw only markers without line between points.
MGL code:
call 'prepare1d' subplot 2 2 0 '':title 'Plot plot (default)':box:plot y subplot 2 2 2 '':title ''!' style; 'rgb' palette':box:plot y 'o!rgb' subplot 2 2 3 '':title 'just markers':box:plot y ' +' new yc 30 'sin(pi*x)':new xc 30 'cos(pi*x)':new z 30 'x' subplot 2 2 1:title '3d variant':rotate 50 60:box:plot xc yc z 'rs'
C++ code:
void smgl_plot(mglGraph *gr)
{
mglData y; mgls_prepare1d(&y); gr->SetOrigin(0,0,0);
if(big!=3) { gr->SubPlot(2,2,0,""); gr->Title("Plot plot (default)"); }
gr->Box(); gr->Plot(y);
if(big==3) return;
gr->SubPlot(2,2,2,""); gr->Title("'!' style; 'rgb' palette"); gr->Box(); gr->Plot(y,"o!rgb");
gr->SubPlot(2,2,3,""); gr->Title("just markers"); gr->Box(); gr->Plot(y," +");
gr->SubPlot(2,2,1); gr->Title("3d variant"); gr->Rotate(50,60); gr->Box();
mglData yc(30), xc(30), z(30); z.Modify("2*x-1");
yc.Modify("sin(pi*(2*x-1))"); xc.Modify("cos(pi*2*x-pi)");
gr->Plot(xc,yc,z,"rs");
}
Next: primitives sample, Previous: plot sample, Up: All samples [Contents][Index]
10.86 Sample ‘pmap’
Function pmap draw Poincare map – show intersections of the curve and the surface.
MGL code:
subplot 1 1 0 '<_^':title 'Poincare map sample' ode r 'cos(y)+sin(z);cos(z)+sin(x);cos(x)+sin(y)' 'xyz' [0.1,0,0] 0.1 100 rotate 40 60:copy x r(0):copy y r(1):copy z r(2) ranges x y z axis:plot x y z 'b' xlabel '\i x' 0:ylabel '\i y' 0:zlabel '\i z' pmap x y z z 'b#o' fsurf '0'
C++ code:
void smgl_pmap(mglGraph *gr)
{
gr->SubPlot(1,1,0,"<_^");
if(big!=3) gr->Title("Poincare map sample");
mglData ini(3); ini[0]=0.1;
mglData r(mglODE("cos(y)+sin(z);cos(z)+sin(x);cos(x)+sin(y)","xyz",ini,0.1,100));
mglData x(r.SubData(0)),y(r.SubData(1)), z(r.SubData(2));
gr->Rotate(40,60); gr->SetRanges(x,y,z);
gr->Axis(); gr->FSurf("0"); gr->Plot(x,y,z,"b");
gr->Label('x',"\\i x",0); gr->Label('y',"\\i y",0); gr->Label('z',"\\i z",0);
gr->Pmap(x,y,z,z, "b#o");
}
Next: projection sample, Previous: pmap sample, Up: All samples [Contents][Index]
10.87 Sample ‘primitives’
Example of primitives: line, curve, rhomb, ellipse, face, sphere, drop, cone.
MGL code:
subplot 2 2 0 '':title 'Line, Curve, Rhomb, Ellipse' '' -1.5
line -1 -1 -0.5 1 'qAI'
curve -0.6 -1 1 1 0 1 1 1 'rA'
ball 0 -0.5 '*':ball 1 -0.1 '*'
rhomb 0 0.4 1 0.9 0.2 'b#'
rhomb 0 0 1 0.4 0.2 'cg@'
ellipse 0 -0.5 1 -0.1 0.2 'u#'
ellipse 0 -1 1 -0.6 0.2 'm@'
subplot 2 3 1 '':title 'Arc, Polygon, Symbol';size -1.2
arc -0.6 0 -0.6 0.3 180 '2kA':ball -0.6 0
polygon 0 0 0 0.4 6 'r'
new x 50 'cos(3*pi*x)':new y 50 'sin(pi*x)'
addsymbol 'a' x y
symbol 0.7 0 'a'
light on
subplot 2 3 3 '<^>' 0 -0.2:title 'Face[xyz]';size -1.5:rotate 50 60:box
facex 1 0 -1 1 1 'r':facey -1 -1 -1 1 1 'g':facez 1 -1 -1 -1 1 'b'
face -1 -1 1 -1 1 1 1 -1 0 1 1 1 'bmgr'
subplot 2 3 5 '':title 'Cone';size -1.5
cone -0.7 -0.3 0 -0.7 0.7 0.5 0.2 0.1 'b':text -0.7 -0.7 'no edges\n(default)';size -1.5
cone 0 -0.3 0 0 0.7 0.5 0.2 0.1 'g@':text 0 -0.7 'with edges\n("\@" style)';size -1.5
cone 0.7 -0.3 0 0.7 0.7 0.5 0.2 0 'Ggb':text 0.7 -0.7 '"arrow" with\n{}gradient';size -1.5
subplot 2 2 2 '':title 'Sphere and Drop'
line -0.9 0 1 0.9 0 1
text -0.9 0.4 'sh=0':drop -0.9 0 0 1 0.5 'r' 0:ball -0.9 0 1 'k'
text -0.3 0.6 'sh=0.33':drop -0.3 0 0 1 0.5 'r' 0.33:ball -0.3 0 1 'k'
text 0.3 0.8 'sh=0.67':drop 0.3 0 0 1 0.5 'r' 0.67:ball 0.3 0 1 'k'
text 0.9 1. 'sh=1':drop 0.9 0 0 1 0.5 'r' 1:ball 0.9 0 1 'k'
text -0.9 -1.1 'asp=0.33':drop -0.9 -0.7 0 1 0.5 'b' 0 0.33
text -0.3 -1.1 'asp=0.67':drop -0.3 -0.7 0 1 0.5 'b' 0 0.67
text 0.3 -1.1 'asp=1':drop 0.3 -0.7 0 1 0.5 'b' 0 1
text 0.9 -1.1 'asp=1.5':drop 0.9 -0.7 0 1 0.5 'b' 0 1.5
C++ code:
void smgl_primitives(mglGraph *gr) // flag #
{
gr->SubPlot(2,2,0,""); gr->Title("Line, Curve, Rhomb, Ellipse","",-1.5);
gr->Line(mglPoint(-1,-1),mglPoint(-0.5,1),"qAI");
gr->Curve(mglPoint(-0.6,-1),mglPoint(1,1),mglPoint(0,1),mglPoint(1,1),"rA");
gr->Rhomb(mglPoint(0,0.4),mglPoint(1,0.9),0.2,"b#");
gr->Rhomb(mglPoint(0,0),mglPoint(1,0.4),0.2,"cg@");
gr->Ellipse(mglPoint(0,-0.5),mglPoint(1,-0.1),0.2,"u#");
gr->Ellipse(mglPoint(0,-1),mglPoint(1,-0.6),0.2,"m@");
gr->Mark(mglPoint(0,-0.5),"*"); gr->Mark(mglPoint(1,-0.1),"*");
gr->SubPlot(2,3,1,""); gr->Title("Arc, Polygon, Symbol","", -1.2*2);
gr->Arc(mglPoint(-0.6,0), mglPoint(-0.6,0.3), 180, "2kA"); gr->Ball(-0.6,0);
gr->Polygon(mglPoint(), mglPoint(0,0.4), 6, "r");
mglData x(50), y(50); gr->Fill(x,"cos(3*pi*x)"); gr->Fill(y,"sin(pi*x)");
gr->DefineSymbol('a',x,y); gr->Symbol(mglPoint(0.7),'a');
gr->Light(true);
gr->SubPlot(2,3,3,"<^>",0,-0.2); gr->Title("Face[xyz]", "", -1.5*2);
gr->Rotate(50,60); gr->Box();
gr->FaceX(mglPoint(1,0,-1),1,1,"r");
gr->FaceY(mglPoint(-1,-1,-1),1,1,"g");
gr->FaceZ(mglPoint(1,-1,-1),-1,1,"b");
gr->Face(mglPoint(-1,-1,1),mglPoint(-1,1,1),mglPoint(1,-1,0),mglPoint(1,1,1),"bmgr");
gr->SubPlot(2,3,5,""); gr->Title("Cone", "", -1.5*2);
gr->Cone(mglPoint(-0.7,-0.3),mglPoint(-0.7,0.7,0.5),0.2,0.1,"b");
gr->Puts(mglPoint(-0.7,-0.7),"no edges\n(default)","", -1.5);
gr->Cone(mglPoint(0,-0.3),mglPoint(0,0.7,0.5),0.2,0.1,"g@");
gr->Puts(mglPoint(0,-0.7),"with edges\n('\\@' style)","", -1.5);
gr->Cone(mglPoint(0.7,-0.3),mglPoint(0.7,0.7,0.5),0.2,0,"ry");
gr->Puts(mglPoint(0.7,-0.7),"'arrow' with\ngradient","", -1.5);
gr->SubPlot(2,2,2,""); gr->Title("Sphere and Drop"); gr->Alpha(false);
gr->Puts(mglPoint(-0.9,0.4),"sh=0"); gr->Ball(mglPoint(-0.9,0,1),'k');
gr->Drop(mglPoint(-0.9,0),mglPoint(0,1),0.5,"r",0);
gr->Puts(mglPoint(-0.3,0.6),"sh=0.33"); gr->Ball(mglPoint(-0.3,0,1),'k');
gr->Drop(mglPoint(-0.3,0),mglPoint(0,1),0.5,"r",0.33);
gr->Puts(mglPoint(0.3,0.8),"sh=0.67"); gr->Ball(mglPoint(0.3,0,1),'k');
gr->Drop(mglPoint(0.3,0),mglPoint(0,1),0.5,"r",0.67);
gr->Puts(mglPoint(0.9,1),"sh=1"); gr->Ball(mglPoint(0.9,0,1),'k');
gr->Drop(mglPoint(0.9,0),mglPoint(0,1),0.5,"r",1);
gr->Line(mglPoint(-0.9,0,1),mglPoint(0.9,0,1),"b");
gr->Puts(mglPoint(-0.9,-1.1),"asp=0.33");
gr->Drop(mglPoint(-0.9,-0.7),mglPoint(0,1),0.5,"b",0,0.33);
gr->Puts(mglPoint(-0.3,-1.1),"asp=0.67");
gr->Drop(mglPoint(-0.3,-0.7),mglPoint(0,1),0.5,"b",0,0.67);
gr->Puts(mglPoint(0.3,-1.1),"asp=1");
gr->Drop(mglPoint(0.3,-0.7),mglPoint(0,1),0.5,"b",0,1);
gr->Puts(mglPoint(0.9,-1.1),"asp=1.5");
gr->Drop(mglPoint(0.9,-0.7),mglPoint(0,1),0.5,"b",0,1.5);
}
Next: projection5 sample, Previous: primitives sample, Up: All samples [Contents][Index]
10.88 Sample ‘projection’
Example of plot projection (ternary=4).
MGL code:
ranges 0 1 0 1 0 1 new x 50 '0.25*(1+cos(2*pi*x))' new y 50 '0.25*(1+sin(2*pi*x))' new z 50 'x' new a 20 30 '30*x*y*(1-x-y)^2*(x+y<1)' new rx 10 'rnd':new ry 10:fill ry '(1-v)*rnd' rx light on title 'Projection sample':ternary 4:rotate 50 60 box:axis:grid plot x y z 'r2':surf a '#' xlabel 'X':ylabel 'Y':zlabel 'Z'
C++ code:
void smgl_projection(mglGraph *gr) // flag #
{
gr->SetRanges(0,1,0,1,0,1);
mglData x(50),y(50),z(50),rx(10),ry(10), a(20,30);
a.Modify("30*x*y*(1-x-y)^2*(x+y<1)");
x.Modify("0.25*(1+cos(2*pi*x))");
y.Modify("0.25*(1+sin(2*pi*x))");
rx.Modify("rnd"); ry.Modify("(1-v)*rnd",rx);
z.Modify("x");
if(big!=3) gr->Title("Projection sample");
gr->Ternary(4);
gr->Rotate(50,60); gr->Light(true);
gr->Plot(x,y,z,"r2"); gr->Surf(a,"#");
gr->Axis(); gr->Grid(); gr->Box();
gr->Label('x',"X",1); gr->Label('y',"Y",1); gr->Label('z',"Z",1);
}
Next: pulse sample, Previous: projection sample, Up: All samples [Contents][Index]
10.89 Sample ‘projection5’
Example of plot projection in ternary coordinates (ternary=5).
MGL code:
ranges 0 1 0 1 0 1 new x 50 '0.25*(1+cos(2*pi*x))' new y 50 '0.25*(1+sin(2*pi*x))' new z 50 'x' new a 20 30 '30*x*y*(1-x-y)^2*(x+y<1)' new rx 10 'rnd':new ry 10:fill ry '(1-v)*rnd' rx light on title 'Projection sample (ternary)':ternary 5:rotate 50 60 box:axis:grid plot x y z 'r2':surf a '#' xlabel 'X':ylabel 'Y':zlabel 'Z'
C++ code:
void smgl_projection5(mglGraph *gr) // flag #
{
gr->SetRanges(0,1,0,1,0,1);
mglData x(50),y(50),z(50),rx(10),ry(10), a(20,30);
a.Modify("30*x*y*(1-x-y)^2*(x+y<1)");
x.Modify("0.25*(1+cos(2*pi*x))");
y.Modify("0.25*(1+sin(2*pi*x))");
rx.Modify("rnd"); ry.Modify("(1-v)*rnd",rx);
z.Modify("x");
if(big!=3) gr->Title("Projection sample (ternary)");
gr->Ternary(5);
gr->Rotate(50,60); gr->Light(true);
gr->Plot(x,y,z,"r2"); gr->Surf(a,"#");
gr->Axis(); gr->Grid(); gr->Box();
gr->Label('x',"X",1); gr->Label('y',"Y",1); gr->Label('z',"Z",1);
}
Next: qo2d sample, Previous: projection5 sample, Up: All samples [Contents][Index]
10.90 Sample ‘pulse’
Example of pulse parameter determining.
MGL code:
subplot 1 1 0 '<_':title 'Pulse sample' new a 100 'exp(-6*x^2)':ranges 0 a.nx-1 0 1 axis:plot a pulse b a 'x' define m a.max line b(1) 0 b(1) m 'r=' line b(1)-b(3)/2 0 b(1)-b(3)/2 m 'm|' line b(1)+b(3)/2 0 b(1)+b(3)/2 m 'm|' line 0 0.5*m a.nx-1 0.5*m 'h' new x 100 'x' plot b(0)*(1-((x-b(1))/b(2))^2) 'g'
C++ code:
void smgl_pulse(mglGraph *gr)
{
gr->SubPlot(1,1,0,"<_");
if(big!=3) gr->Title("Pulse sample");
mglData a(100); gr->Fill(a,"exp(-6*x^2)");
gr->SetRanges(0, a.nx-1, 0, 1);
gr->Axis(); gr->Plot(a);
mglData b(a.Pulse('x'));
double m = b[0];
gr->Line(mglPoint(b[1],0), mglPoint(b[1],m),"r=");
gr->Line(mglPoint(b[1]-b[3]/2,0), mglPoint(b[1]-b[3]/2,m),"m|");
gr->Line(mglPoint(b[1]+b[3]/2,0), mglPoint(b[1]+b[3]/2,m),"m|");
gr->Line(mglPoint(0,m/2), mglPoint(a.nx-1,m/2),"h");
char func[128]; sprintf(func,"%g*(1-((x-%g)/%g)^2)",b[0],b[1],b[2]);
gr->FPlot(func,"g");
}
Next: quality0 sample, Previous: pulse sample, Up: All samples [Contents][Index]
10.91 Sample ‘qo2d’
Example of PDE solving by quasioptical approach qo2d.
MGL code:
define $1 'p^2+q^2-x-1+i*0.5*(y+x)*(y>-x)' subplot 1 1 0 '<_':title 'Beam and ray tracing' ray r $1 -0.7 -1 0 0 0.5 0 0.02 2:plot r(0) r(1) 'k' axis:xlabel '\i x':ylabel '\i z' new re 128 'exp(-48*x^2)':new im 128 new xx 1:new yy 1 qo2d a $1 re im r 1 30 xx yy crange 0 1:dens xx yy a 'wyrRk':fplot '-x' 'k|' text 0 0.85 'absorption: (x+y)/2 for x+y>0' text 0.7 -0.05 'central ray'
C++ code:
void smgl_qo2d(mglGraph *gr)
{
mglData r, xx, yy, a, im(128), re(128);
const char *ham = "p^2+q^2-x-1+i*0.5*(y+x)*(y>-x)";
r = mglRay(ham, mglPoint(-0.7, -1), mglPoint(0, 0.5), 0.02, 2);
if(big!=3) {gr->SubPlot(1,1,0,"<_"); gr->Title("Beam and ray tracing");}
gr->Plot(r.SubData(0), r.SubData(1), "k");
gr->Axis(); gr->Label('x', "\\i x"); gr->Label('y', "\\i y");
// now start beam tracing
gr->Fill(re,"exp(-48*x^2)");
a = mglQO2d(ham, re, im, r, xx, yy, 1, 30);
gr->SetRange('c',0, 1);
gr->Dens(xx, yy, a, "wyrRk");
gr->FPlot("-x", "k|");
gr->Puts(mglPoint(0, 0.85), "absorption: (x+y)/2 for x+y>0");
gr->Puts(mglPoint(0.7, -0.05), "central ray");
}
Next: quality1 sample, Previous: qo2d sample, Up: All samples [Contents][Index]
10.92 Sample ‘quality0’
Show all kind of primitives in quality=0.
MGL code:
quality 0
subplot 3 2 0:define y 0.95
define d 0.3:define x0 0.2:define x1 0.5:define x2 0.6
line x0 1-0*d x1 1-0*d 'k-':text x2 y-0*d 'Solid `-`' ':rL'
line x0 1-1*d x1 1-1*d 'k|':text x2 y-1*d 'Long Dash `|`' ':rL'
line x0 1-2*d x1 1-2*d 'k;':text x2 y-2*d 'Dash 1;`' ':rL'
line x0 1-3*d x1 1-3*d 'k=':text x2 y-3*d 'Small dash `=`' ':rL'
line x0 1-4*d x1 1-4*d 'kj':text x2 y-4*d 'Dash-dot `j`' ':rL'
line x0 1-5*d x1 1-5*d 'ki':text x2 y-5*d 'Small dash-dot `i`' ':rL'
line x0 1-6*d x1 1-6*d 'k:':text x2 y-6*d 'Dots `:`' ':rL'
line x0 1-7*d x1 1-7*d 'k ':text x2 y-7*d 'None ``' ':rL'
define d 0.25:define x0 -0.8:define x1 -1:define x2 -0.05
ball x1 5*d 'k.':text x0 5*d '.' ':rL'
ball x1 4*d 'k+':text x0 4*d '+' ':rL'
ball x1 3*d 'kx':text x0 3*d 'x' ':rL'
ball x1 2*d 'k*':text x0 2*d '*' ':rL'
ball x1 d 'ks':text x0 d 's' ':rL'
ball x1 0 'kd':text x0 0 'd' ':rL'
ball x1 -d 0 'ko':text x0 y-d 'o' ':rL'
ball x1 -2*d 0 'k^':text x0 -2*d '\^' ':rL'
ball x1 -3*d 0 'kv':text x0 -3*d 'v' ':rL'
ball x1 -4*d 0 'k<':text x0 -4*d '<' ':rL'
ball x1 -5*d 0 'k>':text x0 -5*d '>' ':rL'
define x0 -0.3:define x1 -0.5
ball x1 5*d 'k#.':text x0 5*d '\#.' ':rL'
ball x1 4*d 'k#+':text x0 4*d '\#+' ':rL'
ball x1 3*d 'k#x':text x0 3*d '\#x' ':rL'
ball x1 2*d 'k#*':text x0 2*d '\#*' ':rL'
ball x1 d 'k#s':text x0 d '\#s' ':rL'
ball x1 0 'k#d':text x0 0 '\#d' ':rL'
ball x1 -d 0 'k#o':text x0 -d '\#o' ':rL'
ball x1 -2*d 0 'k#^':text x0 -2*d '\#\^' ':rL'
ball x1 -3*d 0 'k#v':text x0 -3*d '\#v' ':rL'
ball x1 -4*d 0 'k#<':text x0 -4*d '\#<' ':rL'
ball x1 -5*d 0 'k#>':text x0 -5*d '\#>' ':rL'
subplot 3 2 1
define a 0.1:define b 0.4:define c 0.5
line a 1 b 1 'k-A':text c 1 'Style `A` or `A\_`' ':rL'
line a 0.8 b 0.8 'k-V':text c 0.8 'Style `V` or `V\_`' ':rL'
line a 0.6 b 0.6 'k-K':text c 0.6 'Style `K` or `K\_`' ':rL'
line a 0.4 b 0.4 'k-I':text c 0.4 'Style `I` or `I\_`' ':rL'
line a 0.2 b 0.2 'k-D':text c 0.2 'Style `D` or `D\_`' ':rL'
line a 0 b 0 'k-S':text c 0 'Style `S` or `S\_`' ':rL'
line a -0.2 b -0.2 'k-O':text c -0.2 'Style `O` or `O\_`' ':rL'
line a -0.4 b -0.4 'k-T':text c -0.4 'Style `T` or `T\_`' ':rL'
line a -0.6 b -0.6 'k-_':text c -0.6 'Style `\_` or none' ':rL'
line a -0.8 b -0.8 'k-AS':text c -0.8 'Style `AS`' ':rL'
line a -1 b -1 'k-_A':text c -1 'Style `\_A`' ':rL'
define a -1:define b -0.7:define c -0.6
line a 1 b 1 'kAA':text c 1 'Style `AA`' ':rL'
line a 0.8 b 0.8 'kVV':text c 0.8 'Style `VV`' ':rL'
line a 0.6 b 0.6 'kKK':text c 0.6 'Style `KK`' ':rL'
line a 0.4 b 0.4 'kII':text c 0.4 'Style `II`' ':rL'
line a 0.2 b 0.2 'kDD':text c 0.2 'Style `DD`' ':rL'
line a 0 b 0 'kSS':text c 0 'Style `SS`' ':rL'
line a -0.2 b -0.2 'kOO':text c -0.2 'Style `OO`' ':rL'
line a -0.4 b -0.4 'kTT':text c -0.4 'Style `TT`' ':rL'
line a -0.6 b -0.6 'k-__':text c -0.6 'Style `\_\_`' ':rL'
line a -0.8 b -0.8 'k-VA':text c -0.8 'Style `VA`' ':rL'
line a -1 b -1 'k-AV':text c -1 'Style `AV`' ':rL'
subplot 3 2 2
#LENUQ
facez -1 -1 0 0.4 0.3 'L#':text -0.8 -0.9 'L' 'w:C' -1.4
facez -0.6 -1 0 0.4 0.3 'E#':text -0.4 -0.9 'E' 'w:C' -1.4
facez -0.2 -1 0 0.4 0.3 'N#':text 0 -0.9 'N' 'w:C' -1.4
facez 0.2 -1 0 0.4 0.3 'U#':text 0.4 -0.9 'U' 'w:C' -1.4
facez 0.6 -1 0 0.4 0.3 'Q#':text 0.8 -0.9 'Q' 'w:C' -1.4
#lenuq
facez -1 -0.7 0 0.4 0.3 'l#':text -0.8 -0.6 'l' 'k:C' -1.4
facez -0.6 -0.7 0 0.4 0.3 'e#':text -0.4 -0.6 'e' 'k:C' -1.4
facez -0.2 -0.7 0 0.4 0.3 'n#':text 0 -0.6 'n' 'k:C' -1.4
facez 0.2 -0.7 0 0.4 0.3 'u#':text 0.4 -0.6 'u' 'k:C' -1.4
facez 0.6 -0.7 0 0.4 0.3 'q#':text 0.8 -0.6 'q' 'k:C' -1.4
#CMYkP
facez -1 -0.4 0 0.4 0.3 'C#':text -0.8 -0.3 'C' 'w:C' -1.4
facez -0.6 -0.4 0 0.4 0.3 'M#':text -0.4 -0.3 'M' 'w:C' -1.4
facez -0.2 -0.4 0 0.4 0.3 'Y#':text 0 -0.3 'Y' 'w:C' -1.4
facez 0.2 -0.4 0 0.4 0.3 'k#':text 0.4 -0.3 'k' 'w:C' -1.4
facez 0.6 -0.4 0 0.4 0.3 'P#':text 0.8 -0.3 'P' 'w:C' -1.4
#cmywp
facez -1 -0.1 0 0.4 0.3 'c#':text -0.8 0 'c' 'k:C' -1.4
facez -0.6 -0.1 0 0.4 0.3 'm#':text -0.4 0 'm' 'k:C' -1.4
facez -0.2 -0.1 0 0.4 0.3 'y#':text 0 0 'y' 'k:C' -1.4
facez 0.2 -0.1 0 0.4 0.3 'w#':text 0.4 0 'w' 'k:C' -1.4
facez 0.6 -0.1 0 0.4 0.3 'p#':text 0.8 0 'p' 'k:C' -1.4
#BGRHW
facez -1 0.2 0 0.4 0.3 'B#':text -0.8 0.3 'B' 'w:C' -1.4
facez -0.6 0.2 0 0.4 0.3 'G#':text -0.4 0.3 'G' 'w:C' -1.4
facez -0.2 0.2 0 0.4 0.3 'R#':text 0 0.3 'R' 'w:C' -1.4
facez 0.2 0.2 0 0.4 0.3 'H#':text 0.4 0.3 'H' 'w:C' -1.4
facez 0.6 0.2 0 0.4 0.3 'W#':text 0.8 0.3 'W' 'w:C' -1.4
#bgrhw
facez -1 0.5 0 0.4 0.3 'b#':text -0.8 0.6 'b' 'k:C' -1.4
facez -0.6 0.5 0 0.4 0.3 'g#':text -0.4 0.6 'g' 'k:C' -1.4
facez -0.2 0.5 0 0.4 0.3 'r#':text 0 0.6 'r' 'k:C' -1.4
facez 0.2 0.5 0 0.4 0.3 'h#':text 0.4 0.6 'h' 'k:C' -1.4
facez 0.6 0.5 0 0.4 0.3 'w#':text 0.8 0.6 'w' 'k:C' -1.4
#brighted
facez -1 0.8 0 0.4 0.3 '{r1}#':text -0.8 0.9 '\{r1\}' 'w:C' -1.4
facez -0.6 0.8 0 0.4 0.3 '{r3}#':text -0.4 0.9 '\{r3\}' 'w:C' -1.4
facez -0.2 0.8 0 0.4 0.3 '{r5}#':text 0 0.9 '\{r5\}' 'k:C' -1.4
facez 0.2 0.8 0 0.4 0.3 '{r7}#':text 0.4 0.9 '\{r7\}' 'k:C' -1.4
facez 0.6 0.8 0 0.4 0.3 '{r9}#':text 0.8 0.9 '\{r9\}' 'k:C' -1.4
# HEX
facez -1 -1.3 0 1 0.3 '{xff9966}#':text -0.5 -1.2 '\{xff9966\}' 'k:C' -1.4
facez 0 -1.3 0 1 0.3 '{x83CAFF}#':text 0.5 -1.2 '\{x83caff\}' 'k:C' -1.4
subplot 3 2 3
for $i 0 9
line -1 0.2*$i-1 1 0.2*$i-1 'r','0'+$i
text 1.05 0.2*$i-1 '0'+$i ':L'
next
subplot 3 2 4:title 'TriPlot sample':rotate 50 60
list tt 0 1 2 | 0 1 3 | 0 2 3 | 1 2 3
list xt -1 1 0 0:list yt -1 -1 1 0:list zt -1 -1 -1 1:light on
triplot tt xt yt zt 'b':triplot tt xt yt zt 'k#'
subplot 3 2 5:new r 4 'i+1':ranges 1 4 1 4
axis:mark r r 's':plot r 'b'
C++ code:
void smgl_quality0(mglGraph *gr) // test file export
{
gr->SetQuality(0); all_prims(gr);
}
Next: quality2 sample, Previous: quality0 sample, Up: All samples [Contents][Index]
10.93 Sample ‘quality1’
Show all kind of primitives in quality=1.
MGL code:
quality 1
subplot 3 2 0:define y 0.95
define d 0.3:define x0 0.2:define x1 0.5:define x2 0.6
line x0 1-0*d x1 1-0*d 'k-':text x2 y-0*d 'Solid `-`' ':rL'
line x0 1-1*d x1 1-1*d 'k|':text x2 y-1*d 'Long Dash `|`' ':rL'
line x0 1-2*d x1 1-2*d 'k;':text x2 y-2*d 'Dash 1;`' ':rL'
line x0 1-3*d x1 1-3*d 'k=':text x2 y-3*d 'Small dash `=`' ':rL'
line x0 1-4*d x1 1-4*d 'kj':text x2 y-4*d 'Dash-dot `j`' ':rL'
line x0 1-5*d x1 1-5*d 'ki':text x2 y-5*d 'Small dash-dot `i`' ':rL'
line x0 1-6*d x1 1-6*d 'k:':text x2 y-6*d 'Dots `:`' ':rL'
line x0 1-7*d x1 1-7*d 'k ':text x2 y-7*d 'None ``' ':rL'
define d 0.25:define x0 -0.8:define x1 -1:define x2 -0.05
ball x1 5*d 'k.':text x0 5*d '.' ':rL'
ball x1 4*d 'k+':text x0 4*d '+' ':rL'
ball x1 3*d 'kx':text x0 3*d 'x' ':rL'
ball x1 2*d 'k*':text x0 2*d '*' ':rL'
ball x1 d 'ks':text x0 d 's' ':rL'
ball x1 0 'kd':text x0 0 'd' ':rL'
ball x1 -d 0 'ko':text x0 y-d 'o' ':rL'
ball x1 -2*d 0 'k^':text x0 -2*d '\^' ':rL'
ball x1 -3*d 0 'kv':text x0 -3*d 'v' ':rL'
ball x1 -4*d 0 'k<':text x0 -4*d '<' ':rL'
ball x1 -5*d 0 'k>':text x0 -5*d '>' ':rL'
define x0 -0.3:define x1 -0.5
ball x1 5*d 'k#.':text x0 5*d '\#.' ':rL'
ball x1 4*d 'k#+':text x0 4*d '\#+' ':rL'
ball x1 3*d 'k#x':text x0 3*d '\#x' ':rL'
ball x1 2*d 'k#*':text x0 2*d '\#*' ':rL'
ball x1 d 'k#s':text x0 d '\#s' ':rL'
ball x1 0 'k#d':text x0 0 '\#d' ':rL'
ball x1 -d 0 'k#o':text x0 -d '\#o' ':rL'
ball x1 -2*d 0 'k#^':text x0 -2*d '\#\^' ':rL'
ball x1 -3*d 0 'k#v':text x0 -3*d '\#v' ':rL'
ball x1 -4*d 0 'k#<':text x0 -4*d '\#<' ':rL'
ball x1 -5*d 0 'k#>':text x0 -5*d '\#>' ':rL'
subplot 3 2 1
define a 0.1:define b 0.4:define c 0.5
line a 1 b 1 'k-A':text c 1 'Style `A` or `A\_`' ':rL'
line a 0.8 b 0.8 'k-V':text c 0.8 'Style `V` or `V\_`' ':rL'
line a 0.6 b 0.6 'k-K':text c 0.6 'Style `K` or `K\_`' ':rL'
line a 0.4 b 0.4 'k-I':text c 0.4 'Style `I` or `I\_`' ':rL'
line a 0.2 b 0.2 'k-D':text c 0.2 'Style `D` or `D\_`' ':rL'
line a 0 b 0 'k-S':text c 0 'Style `S` or `S\_`' ':rL'
line a -0.2 b -0.2 'k-O':text c -0.2 'Style `O` or `O\_`' ':rL'
line a -0.4 b -0.4 'k-T':text c -0.4 'Style `T` or `T\_`' ':rL'
line a -0.6 b -0.6 'k-_':text c -0.6 'Style `\_` or none' ':rL'
line a -0.8 b -0.8 'k-AS':text c -0.8 'Style `AS`' ':rL'
line a -1 b -1 'k-_A':text c -1 'Style `\_A`' ':rL'
define a -1:define b -0.7:define c -0.6
line a 1 b 1 'kAA':text c 1 'Style `AA`' ':rL'
line a 0.8 b 0.8 'kVV':text c 0.8 'Style `VV`' ':rL'
line a 0.6 b 0.6 'kKK':text c 0.6 'Style `KK`' ':rL'
line a 0.4 b 0.4 'kII':text c 0.4 'Style `II`' ':rL'
line a 0.2 b 0.2 'kDD':text c 0.2 'Style `DD`' ':rL'
line a 0 b 0 'kSS':text c 0 'Style `SS`' ':rL'
line a -0.2 b -0.2 'kOO':text c -0.2 'Style `OO`' ':rL'
line a -0.4 b -0.4 'kTT':text c -0.4 'Style `TT`' ':rL'
line a -0.6 b -0.6 'k-__':text c -0.6 'Style `\_\_`' ':rL'
line a -0.8 b -0.8 'k-VA':text c -0.8 'Style `VA`' ':rL'
line a -1 b -1 'k-AV':text c -1 'Style `AV`' ':rL'
subplot 3 2 2
#LENUQ
facez -1 -1 0 0.4 0.3 'L#':text -0.8 -0.9 'L' 'w:C' -1.4
facez -0.6 -1 0 0.4 0.3 'E#':text -0.4 -0.9 'E' 'w:C' -1.4
facez -0.2 -1 0 0.4 0.3 'N#':text 0 -0.9 'N' 'w:C' -1.4
facez 0.2 -1 0 0.4 0.3 'U#':text 0.4 -0.9 'U' 'w:C' -1.4
facez 0.6 -1 0 0.4 0.3 'Q#':text 0.8 -0.9 'Q' 'w:C' -1.4
#lenuq
facez -1 -0.7 0 0.4 0.3 'l#':text -0.8 -0.6 'l' 'k:C' -1.4
facez -0.6 -0.7 0 0.4 0.3 'e#':text -0.4 -0.6 'e' 'k:C' -1.4
facez -0.2 -0.7 0 0.4 0.3 'n#':text 0 -0.6 'n' 'k:C' -1.4
facez 0.2 -0.7 0 0.4 0.3 'u#':text 0.4 -0.6 'u' 'k:C' -1.4
facez 0.6 -0.7 0 0.4 0.3 'q#':text 0.8 -0.6 'q' 'k:C' -1.4
#CMYkP
facez -1 -0.4 0 0.4 0.3 'C#':text -0.8 -0.3 'C' 'w:C' -1.4
facez -0.6 -0.4 0 0.4 0.3 'M#':text -0.4 -0.3 'M' 'w:C' -1.4
facez -0.2 -0.4 0 0.4 0.3 'Y#':text 0 -0.3 'Y' 'w:C' -1.4
facez 0.2 -0.4 0 0.4 0.3 'k#':text 0.4 -0.3 'k' 'w:C' -1.4
facez 0.6 -0.4 0 0.4 0.3 'P#':text 0.8 -0.3 'P' 'w:C' -1.4
#cmywp
facez -1 -0.1 0 0.4 0.3 'c#':text -0.8 0 'c' 'k:C' -1.4
facez -0.6 -0.1 0 0.4 0.3 'm#':text -0.4 0 'm' 'k:C' -1.4
facez -0.2 -0.1 0 0.4 0.3 'y#':text 0 0 'y' 'k:C' -1.4
facez 0.2 -0.1 0 0.4 0.3 'w#':text 0.4 0 'w' 'k:C' -1.4
facez 0.6 -0.1 0 0.4 0.3 'p#':text 0.8 0 'p' 'k:C' -1.4
#BGRHW
facez -1 0.2 0 0.4 0.3 'B#':text -0.8 0.3 'B' 'w:C' -1.4
facez -0.6 0.2 0 0.4 0.3 'G#':text -0.4 0.3 'G' 'w:C' -1.4
facez -0.2 0.2 0 0.4 0.3 'R#':text 0 0.3 'R' 'w:C' -1.4
facez 0.2 0.2 0 0.4 0.3 'H#':text 0.4 0.3 'H' 'w:C' -1.4
facez 0.6 0.2 0 0.4 0.3 'W#':text 0.8 0.3 'W' 'w:C' -1.4
#bgrhw
facez -1 0.5 0 0.4 0.3 'b#':text -0.8 0.6 'b' 'k:C' -1.4
facez -0.6 0.5 0 0.4 0.3 'g#':text -0.4 0.6 'g' 'k:C' -1.4
facez -0.2 0.5 0 0.4 0.3 'r#':text 0 0.6 'r' 'k:C' -1.4
facez 0.2 0.5 0 0.4 0.3 'h#':text 0.4 0.6 'h' 'k:C' -1.4
facez 0.6 0.5 0 0.4 0.3 'w#':text 0.8 0.6 'w' 'k:C' -1.4
#brighted
facez -1 0.8 0 0.4 0.3 '{r1}#':text -0.8 0.9 '\{r1\}' 'w:C' -1.4
facez -0.6 0.8 0 0.4 0.3 '{r3}#':text -0.4 0.9 '\{r3\}' 'w:C' -1.4
facez -0.2 0.8 0 0.4 0.3 '{r5}#':text 0 0.9 '\{r5\}' 'k:C' -1.4
facez 0.2 0.8 0 0.4 0.3 '{r7}#':text 0.4 0.9 '\{r7\}' 'k:C' -1.4
facez 0.6 0.8 0 0.4 0.3 '{r9}#':text 0.8 0.9 '\{r9\}' 'k:C' -1.4
# HEX
facez -1 -1.3 0 1 0.3 '{xff9966}#':text -0.5 -1.2 '\{xff9966\}' 'k:C' -1.4
facez 0 -1.3 0 1 0.3 '{x83CAFF}#':text 0.5 -1.2 '\{x83caff\}' 'k:C' -1.4
subplot 3 2 3
for $i 0 9
line -1 0.2*$i-1 1 0.2*$i-1 'r','0'+$i
text 1.05 0.2*$i-1 '0'+$i ':L'
next
subplot 3 2 4:title 'TriPlot sample':rotate 50 60
list tt 0 1 2 | 0 1 3 | 0 2 3 | 1 2 3
list xt -1 1 0 0:list yt -1 -1 1 0:list zt -1 -1 -1 1:light on
triplot tt xt yt zt 'b':triplot tt xt yt zt 'k#'
subplot 3 2 5:new r 4 'i+1':ranges 1 4 1 4
axis:mark r r 's':plot r 'b'
C++ code:
void smgl_quality1(mglGraph *gr) // test file export
{
gr->SetQuality(1); all_prims(gr);
}
Next: quality4 sample, Previous: quality1 sample, Up: All samples [Contents][Index]
10.94 Sample ‘quality2’
Show all kind of primitives in quality=2.
MGL code:
quality 2
subplot 3 2 0:define y 0.95
define d 0.3:define x0 0.2:define x1 0.5:define x2 0.6
line x0 1-0*d x1 1-0*d 'k-':text x2 y-0*d 'Solid `-`' ':rL'
line x0 1-1*d x1 1-1*d 'k|':text x2 y-1*d 'Long Dash `|`' ':rL'
line x0 1-2*d x1 1-2*d 'k;':text x2 y-2*d 'Dash 1;`' ':rL'
line x0 1-3*d x1 1-3*d 'k=':text x2 y-3*d 'Small dash `=`' ':rL'
line x0 1-4*d x1 1-4*d 'kj':text x2 y-4*d 'Dash-dot `j`' ':rL'
line x0 1-5*d x1 1-5*d 'ki':text x2 y-5*d 'Small dash-dot `i`' ':rL'
line x0 1-6*d x1 1-6*d 'k:':text x2 y-6*d 'Dots `:`' ':rL'
line x0 1-7*d x1 1-7*d 'k ':text x2 y-7*d 'None ``' ':rL'
define d 0.25:define x0 -0.8:define x1 -1:define x2 -0.05
ball x1 5*d 'k.':text x0 5*d '.' ':rL'
ball x1 4*d 'k+':text x0 4*d '+' ':rL'
ball x1 3*d 'kx':text x0 3*d 'x' ':rL'
ball x1 2*d 'k*':text x0 2*d '*' ':rL'
ball x1 d 'ks':text x0 d 's' ':rL'
ball x1 0 'kd':text x0 0 'd' ':rL'
ball x1 -d 0 'ko':text x0 y-d 'o' ':rL'
ball x1 -2*d 0 'k^':text x0 -2*d '\^' ':rL'
ball x1 -3*d 0 'kv':text x0 -3*d 'v' ':rL'
ball x1 -4*d 0 'k<':text x0 -4*d '<' ':rL'
ball x1 -5*d 0 'k>':text x0 -5*d '>' ':rL'
define x0 -0.3:define x1 -0.5
ball x1 5*d 'k#.':text x0 5*d '\#.' ':rL'
ball x1 4*d 'k#+':text x0 4*d '\#+' ':rL'
ball x1 3*d 'k#x':text x0 3*d '\#x' ':rL'
ball x1 2*d 'k#*':text x0 2*d '\#*' ':rL'
ball x1 d 'k#s':text x0 d '\#s' ':rL'
ball x1 0 'k#d':text x0 0 '\#d' ':rL'
ball x1 -d 0 'k#o':text x0 -d '\#o' ':rL'
ball x1 -2*d 0 'k#^':text x0 -2*d '\#\^' ':rL'
ball x1 -3*d 0 'k#v':text x0 -3*d '\#v' ':rL'
ball x1 -4*d 0 'k#<':text x0 -4*d '\#<' ':rL'
ball x1 -5*d 0 'k#>':text x0 -5*d '\#>' ':rL'
subplot 3 2 1
define a 0.1:define b 0.4:define c 0.5
line a 1 b 1 'k-A':text c 1 'Style `A` or `A\_`' ':rL'
line a 0.8 b 0.8 'k-V':text c 0.8 'Style `V` or `V\_`' ':rL'
line a 0.6 b 0.6 'k-K':text c 0.6 'Style `K` or `K\_`' ':rL'
line a 0.4 b 0.4 'k-I':text c 0.4 'Style `I` or `I\_`' ':rL'
line a 0.2 b 0.2 'k-D':text c 0.2 'Style `D` or `D\_`' ':rL'
line a 0 b 0 'k-S':text c 0 'Style `S` or `S\_`' ':rL'
line a -0.2 b -0.2 'k-O':text c -0.2 'Style `O` or `O\_`' ':rL'
line a -0.4 b -0.4 'k-T':text c -0.4 'Style `T` or `T\_`' ':rL'
line a -0.6 b -0.6 'k-_':text c -0.6 'Style `\_` or none' ':rL'
line a -0.8 b -0.8 'k-AS':text c -0.8 'Style `AS`' ':rL'
line a -1 b -1 'k-_A':text c -1 'Style `\_A`' ':rL'
define a -1:define b -0.7:define c -0.6
line a 1 b 1 'kAA':text c 1 'Style `AA`' ':rL'
line a 0.8 b 0.8 'kVV':text c 0.8 'Style `VV`' ':rL'
line a 0.6 b 0.6 'kKK':text c 0.6 'Style `KK`' ':rL'
line a 0.4 b 0.4 'kII':text c 0.4 'Style `II`' ':rL'
line a 0.2 b 0.2 'kDD':text c 0.2 'Style `DD`' ':rL'
line a 0 b 0 'kSS':text c 0 'Style `SS`' ':rL'
line a -0.2 b -0.2 'kOO':text c -0.2 'Style `OO`' ':rL'
line a -0.4 b -0.4 'kTT':text c -0.4 'Style `TT`' ':rL'
line a -0.6 b -0.6 'k-__':text c -0.6 'Style `\_\_`' ':rL'
line a -0.8 b -0.8 'k-VA':text c -0.8 'Style `VA`' ':rL'
line a -1 b -1 'k-AV':text c -1 'Style `AV`' ':rL'
subplot 3 2 2
#LENUQ
facez -1 -1 0 0.4 0.3 'L#':text -0.8 -0.9 'L' 'w:C' -1.4
facez -0.6 -1 0 0.4 0.3 'E#':text -0.4 -0.9 'E' 'w:C' -1.4
facez -0.2 -1 0 0.4 0.3 'N#':text 0 -0.9 'N' 'w:C' -1.4
facez 0.2 -1 0 0.4 0.3 'U#':text 0.4 -0.9 'U' 'w:C' -1.4
facez 0.6 -1 0 0.4 0.3 'Q#':text 0.8 -0.9 'Q' 'w:C' -1.4
#lenuq
facez -1 -0.7 0 0.4 0.3 'l#':text -0.8 -0.6 'l' 'k:C' -1.4
facez -0.6 -0.7 0 0.4 0.3 'e#':text -0.4 -0.6 'e' 'k:C' -1.4
facez -0.2 -0.7 0 0.4 0.3 'n#':text 0 -0.6 'n' 'k:C' -1.4
facez 0.2 -0.7 0 0.4 0.3 'u#':text 0.4 -0.6 'u' 'k:C' -1.4
facez 0.6 -0.7 0 0.4 0.3 'q#':text 0.8 -0.6 'q' 'k:C' -1.4
#CMYkP
facez -1 -0.4 0 0.4 0.3 'C#':text -0.8 -0.3 'C' 'w:C' -1.4
facez -0.6 -0.4 0 0.4 0.3 'M#':text -0.4 -0.3 'M' 'w:C' -1.4
facez -0.2 -0.4 0 0.4 0.3 'Y#':text 0 -0.3 'Y' 'w:C' -1.4
facez 0.2 -0.4 0 0.4 0.3 'k#':text 0.4 -0.3 'k' 'w:C' -1.4
facez 0.6 -0.4 0 0.4 0.3 'P#':text 0.8 -0.3 'P' 'w:C' -1.4
#cmywp
facez -1 -0.1 0 0.4 0.3 'c#':text -0.8 0 'c' 'k:C' -1.4
facez -0.6 -0.1 0 0.4 0.3 'm#':text -0.4 0 'm' 'k:C' -1.4
facez -0.2 -0.1 0 0.4 0.3 'y#':text 0 0 'y' 'k:C' -1.4
facez 0.2 -0.1 0 0.4 0.3 'w#':text 0.4 0 'w' 'k:C' -1.4
facez 0.6 -0.1 0 0.4 0.3 'p#':text 0.8 0 'p' 'k:C' -1.4
#BGRHW
facez -1 0.2 0 0.4 0.3 'B#':text -0.8 0.3 'B' 'w:C' -1.4
facez -0.6 0.2 0 0.4 0.3 'G#':text -0.4 0.3 'G' 'w:C' -1.4
facez -0.2 0.2 0 0.4 0.3 'R#':text 0 0.3 'R' 'w:C' -1.4
facez 0.2 0.2 0 0.4 0.3 'H#':text 0.4 0.3 'H' 'w:C' -1.4
facez 0.6 0.2 0 0.4 0.3 'W#':text 0.8 0.3 'W' 'w:C' -1.4
#bgrhw
facez -1 0.5 0 0.4 0.3 'b#':text -0.8 0.6 'b' 'k:C' -1.4
facez -0.6 0.5 0 0.4 0.3 'g#':text -0.4 0.6 'g' 'k:C' -1.4
facez -0.2 0.5 0 0.4 0.3 'r#':text 0 0.6 'r' 'k:C' -1.4
facez 0.2 0.5 0 0.4 0.3 'h#':text 0.4 0.6 'h' 'k:C' -1.4
facez 0.6 0.5 0 0.4 0.3 'w#':text 0.8 0.6 'w' 'k:C' -1.4
#brighted
facez -1 0.8 0 0.4 0.3 '{r1}#':text -0.8 0.9 '\{r1\}' 'w:C' -1.4
facez -0.6 0.8 0 0.4 0.3 '{r3}#':text -0.4 0.9 '\{r3\}' 'w:C' -1.4
facez -0.2 0.8 0 0.4 0.3 '{r5}#':text 0 0.9 '\{r5\}' 'k:C' -1.4
facez 0.2 0.8 0 0.4 0.3 '{r7}#':text 0.4 0.9 '\{r7\}' 'k:C' -1.4
facez 0.6 0.8 0 0.4 0.3 '{r9}#':text 0.8 0.9 '\{r9\}' 'k:C' -1.4
# HEX
facez -1 -1.3 0 1 0.3 '{xff9966}#':text -0.5 -1.2 '\{xff9966\}' 'k:C' -1.4
facez 0 -1.3 0 1 0.3 '{x83CAFF}#':text 0.5 -1.2 '\{x83caff\}' 'k:C' -1.4
subplot 3 2 3
for $i 0 9
line -1 0.2*$i-1 1 0.2*$i-1 'r','0'+$i
text 1.05 0.2*$i-1 '0'+$i ':L'
next
subplot 3 2 4:title 'TriPlot sample':rotate 50 60
list tt 0 1 2 | 0 1 3 | 0 2 3 | 1 2 3
list xt -1 1 0 0:list yt -1 -1 1 0:list zt -1 -1 -1 1:light on
triplot tt xt yt zt 'b':triplot tt xt yt zt 'k#'
subplot 3 2 5:new r 4 'i+1':ranges 1 4 1 4
axis:mark r r 's':plot r 'b'
C++ code:
void smgl_quality2(mglGraph *gr) // test file export
{
gr->SetQuality(2); all_prims(gr);
}
Next: quality5 sample, Previous: quality2 sample, Up: All samples [Contents][Index]
10.95 Sample ‘quality4’
Show all kind of primitives in quality=4.
MGL code:
quality 4
subplot 3 2 0:define y 0.95
define d 0.3:define x0 0.2:define x1 0.5:define x2 0.6
line x0 1-0*d x1 1-0*d 'k-':text x2 y-0*d 'Solid `-`' ':rL'
line x0 1-1*d x1 1-1*d 'k|':text x2 y-1*d 'Long Dash `|`' ':rL'
line x0 1-2*d x1 1-2*d 'k;':text x2 y-2*d 'Dash 1;`' ':rL'
line x0 1-3*d x1 1-3*d 'k=':text x2 y-3*d 'Small dash `=`' ':rL'
line x0 1-4*d x1 1-4*d 'kj':text x2 y-4*d 'Dash-dot `j`' ':rL'
line x0 1-5*d x1 1-5*d 'ki':text x2 y-5*d 'Small dash-dot `i`' ':rL'
line x0 1-6*d x1 1-6*d 'k:':text x2 y-6*d 'Dots `:`' ':rL'
line x0 1-7*d x1 1-7*d 'k ':text x2 y-7*d 'None ``' ':rL'
define d 0.25:define x0 -0.8:define x1 -1:define x2 -0.05
ball x1 5*d 'k.':text x0 5*d '.' ':rL'
ball x1 4*d 'k+':text x0 4*d '+' ':rL'
ball x1 3*d 'kx':text x0 3*d 'x' ':rL'
ball x1 2*d 'k*':text x0 2*d '*' ':rL'
ball x1 d 'ks':text x0 d 's' ':rL'
ball x1 0 'kd':text x0 0 'd' ':rL'
ball x1 -d 0 'ko':text x0 y-d 'o' ':rL'
ball x1 -2*d 0 'k^':text x0 -2*d '\^' ':rL'
ball x1 -3*d 0 'kv':text x0 -3*d 'v' ':rL'
ball x1 -4*d 0 'k<':text x0 -4*d '<' ':rL'
ball x1 -5*d 0 'k>':text x0 -5*d '>' ':rL'
define x0 -0.3:define x1 -0.5
ball x1 5*d 'k#.':text x0 5*d '\#.' ':rL'
ball x1 4*d 'k#+':text x0 4*d '\#+' ':rL'
ball x1 3*d 'k#x':text x0 3*d '\#x' ':rL'
ball x1 2*d 'k#*':text x0 2*d '\#*' ':rL'
ball x1 d 'k#s':text x0 d '\#s' ':rL'
ball x1 0 'k#d':text x0 0 '\#d' ':rL'
ball x1 -d 0 'k#o':text x0 -d '\#o' ':rL'
ball x1 -2*d 0 'k#^':text x0 -2*d '\#\^' ':rL'
ball x1 -3*d 0 'k#v':text x0 -3*d '\#v' ':rL'
ball x1 -4*d 0 'k#<':text x0 -4*d '\#<' ':rL'
ball x1 -5*d 0 'k#>':text x0 -5*d '\#>' ':rL'
subplot 3 2 1
define a 0.1:define b 0.4:define c 0.5
line a 1 b 1 'k-A':text c 1 'Style `A` or `A\_`' ':rL'
line a 0.8 b 0.8 'k-V':text c 0.8 'Style `V` or `V\_`' ':rL'
line a 0.6 b 0.6 'k-K':text c 0.6 'Style `K` or `K\_`' ':rL'
line a 0.4 b 0.4 'k-I':text c 0.4 'Style `I` or `I\_`' ':rL'
line a 0.2 b 0.2 'k-D':text c 0.2 'Style `D` or `D\_`' ':rL'
line a 0 b 0 'k-S':text c 0 'Style `S` or `S\_`' ':rL'
line a -0.2 b -0.2 'k-O':text c -0.2 'Style `O` or `O\_`' ':rL'
line a -0.4 b -0.4 'k-T':text c -0.4 'Style `T` or `T\_`' ':rL'
line a -0.6 b -0.6 'k-_':text c -0.6 'Style `\_` or none' ':rL'
line a -0.8 b -0.8 'k-AS':text c -0.8 'Style `AS`' ':rL'
line a -1 b -1 'k-_A':text c -1 'Style `\_A`' ':rL'
define a -1:define b -0.7:define c -0.6
line a 1 b 1 'kAA':text c 1 'Style `AA`' ':rL'
line a 0.8 b 0.8 'kVV':text c 0.8 'Style `VV`' ':rL'
line a 0.6 b 0.6 'kKK':text c 0.6 'Style `KK`' ':rL'
line a 0.4 b 0.4 'kII':text c 0.4 'Style `II`' ':rL'
line a 0.2 b 0.2 'kDD':text c 0.2 'Style `DD`' ':rL'
line a 0 b 0 'kSS':text c 0 'Style `SS`' ':rL'
line a -0.2 b -0.2 'kOO':text c -0.2 'Style `OO`' ':rL'
line a -0.4 b -0.4 'kTT':text c -0.4 'Style `TT`' ':rL'
line a -0.6 b -0.6 'k-__':text c -0.6 'Style `\_\_`' ':rL'
line a -0.8 b -0.8 'k-VA':text c -0.8 'Style `VA`' ':rL'
line a -1 b -1 'k-AV':text c -1 'Style `AV`' ':rL'
subplot 3 2 2
#LENUQ
facez -1 -1 0 0.4 0.3 'L#':text -0.8 -0.9 'L' 'w:C' -1.4
facez -0.6 -1 0 0.4 0.3 'E#':text -0.4 -0.9 'E' 'w:C' -1.4
facez -0.2 -1 0 0.4 0.3 'N#':text 0 -0.9 'N' 'w:C' -1.4
facez 0.2 -1 0 0.4 0.3 'U#':text 0.4 -0.9 'U' 'w:C' -1.4
facez 0.6 -1 0 0.4 0.3 'Q#':text 0.8 -0.9 'Q' 'w:C' -1.4
#lenuq
facez -1 -0.7 0 0.4 0.3 'l#':text -0.8 -0.6 'l' 'k:C' -1.4
facez -0.6 -0.7 0 0.4 0.3 'e#':text -0.4 -0.6 'e' 'k:C' -1.4
facez -0.2 -0.7 0 0.4 0.3 'n#':text 0 -0.6 'n' 'k:C' -1.4
facez 0.2 -0.7 0 0.4 0.3 'u#':text 0.4 -0.6 'u' 'k:C' -1.4
facez 0.6 -0.7 0 0.4 0.3 'q#':text 0.8 -0.6 'q' 'k:C' -1.4
#CMYkP
facez -1 -0.4 0 0.4 0.3 'C#':text -0.8 -0.3 'C' 'w:C' -1.4
facez -0.6 -0.4 0 0.4 0.3 'M#':text -0.4 -0.3 'M' 'w:C' -1.4
facez -0.2 -0.4 0 0.4 0.3 'Y#':text 0 -0.3 'Y' 'w:C' -1.4
facez 0.2 -0.4 0 0.4 0.3 'k#':text 0.4 -0.3 'k' 'w:C' -1.4
facez 0.6 -0.4 0 0.4 0.3 'P#':text 0.8 -0.3 'P' 'w:C' -1.4
#cmywp
facez -1 -0.1 0 0.4 0.3 'c#':text -0.8 0 'c' 'k:C' -1.4
facez -0.6 -0.1 0 0.4 0.3 'm#':text -0.4 0 'm' 'k:C' -1.4
facez -0.2 -0.1 0 0.4 0.3 'y#':text 0 0 'y' 'k:C' -1.4
facez 0.2 -0.1 0 0.4 0.3 'w#':text 0.4 0 'w' 'k:C' -1.4
facez 0.6 -0.1 0 0.4 0.3 'p#':text 0.8 0 'p' 'k:C' -1.4
#BGRHW
facez -1 0.2 0 0.4 0.3 'B#':text -0.8 0.3 'B' 'w:C' -1.4
facez -0.6 0.2 0 0.4 0.3 'G#':text -0.4 0.3 'G' 'w:C' -1.4
facez -0.2 0.2 0 0.4 0.3 'R#':text 0 0.3 'R' 'w:C' -1.4
facez 0.2 0.2 0 0.4 0.3 'H#':text 0.4 0.3 'H' 'w:C' -1.4
facez 0.6 0.2 0 0.4 0.3 'W#':text 0.8 0.3 'W' 'w:C' -1.4
#bgrhw
facez -1 0.5 0 0.4 0.3 'b#':text -0.8 0.6 'b' 'k:C' -1.4
facez -0.6 0.5 0 0.4 0.3 'g#':text -0.4 0.6 'g' 'k:C' -1.4
facez -0.2 0.5 0 0.4 0.3 'r#':text 0 0.6 'r' 'k:C' -1.4
facez 0.2 0.5 0 0.4 0.3 'h#':text 0.4 0.6 'h' 'k:C' -1.4
facez 0.6 0.5 0 0.4 0.3 'w#':text 0.8 0.6 'w' 'k:C' -1.4
#brighted
facez -1 0.8 0 0.4 0.3 '{r1}#':text -0.8 0.9 '\{r1\}' 'w:C' -1.4
facez -0.6 0.8 0 0.4 0.3 '{r3}#':text -0.4 0.9 '\{r3\}' 'w:C' -1.4
facez -0.2 0.8 0 0.4 0.3 '{r5}#':text 0 0.9 '\{r5\}' 'k:C' -1.4
facez 0.2 0.8 0 0.4 0.3 '{r7}#':text 0.4 0.9 '\{r7\}' 'k:C' -1.4
facez 0.6 0.8 0 0.4 0.3 '{r9}#':text 0.8 0.9 '\{r9\}' 'k:C' -1.4
# HEX
facez -1 -1.3 0 1 0.3 '{xff9966}#':text -0.5 -1.2 '\{xff9966\}' 'k:C' -1.4
facez 0 -1.3 0 1 0.3 '{x83CAFF}#':text 0.5 -1.2 '\{x83caff\}' 'k:C' -1.4
subplot 3 2 3
for $i 0 9
line -1 0.2*$i-1 1 0.2*$i-1 'r','0'+$i
text 1.05 0.2*$i-1 '0'+$i ':L'
next
subplot 3 2 4:title 'TriPlot sample':rotate 50 60
list tt 0 1 2 | 0 1 3 | 0 2 3 | 1 2 3
list xt -1 1 0 0:list yt -1 -1 1 0:list zt -1 -1 -1 1:light on
triplot tt xt yt zt 'b':triplot tt xt yt zt 'k#'
subplot 3 2 5:new r 4 'i+1':ranges 1 4 1 4
axis:mark r r 's':plot r 'b'
C++ code:
void smgl_quality4(mglGraph *gr) // test file export
{
gr->SetQuality(4); all_prims(gr);
}
Next: quality6 sample, Previous: quality4 sample, Up: All samples [Contents][Index]
10.96 Sample ‘quality5’
Show all kind of primitives in quality=5.
MGL code:
quality 5
subplot 3 2 0:define y 0.95
define d 0.3:define x0 0.2:define x1 0.5:define x2 0.6
line x0 1-0*d x1 1-0*d 'k-':text x2 y-0*d 'Solid `-`' ':rL'
line x0 1-1*d x1 1-1*d 'k|':text x2 y-1*d 'Long Dash `|`' ':rL'
line x0 1-2*d x1 1-2*d 'k;':text x2 y-2*d 'Dash 1;`' ':rL'
line x0 1-3*d x1 1-3*d 'k=':text x2 y-3*d 'Small dash `=`' ':rL'
line x0 1-4*d x1 1-4*d 'kj':text x2 y-4*d 'Dash-dot `j`' ':rL'
line x0 1-5*d x1 1-5*d 'ki':text x2 y-5*d 'Small dash-dot `i`' ':rL'
line x0 1-6*d x1 1-6*d 'k:':text x2 y-6*d 'Dots `:`' ':rL'
line x0 1-7*d x1 1-7*d 'k ':text x2 y-7*d 'None ``' ':rL'
define d 0.25:define x0 -0.8:define x1 -1:define x2 -0.05
ball x1 5*d 'k.':text x0 5*d '.' ':rL'
ball x1 4*d 'k+':text x0 4*d '+' ':rL'
ball x1 3*d 'kx':text x0 3*d 'x' ':rL'
ball x1 2*d 'k*':text x0 2*d '*' ':rL'
ball x1 d 'ks':text x0 d 's' ':rL'
ball x1 0 'kd':text x0 0 'd' ':rL'
ball x1 -d 0 'ko':text x0 y-d 'o' ':rL'
ball x1 -2*d 0 'k^':text x0 -2*d '\^' ':rL'
ball x1 -3*d 0 'kv':text x0 -3*d 'v' ':rL'
ball x1 -4*d 0 'k<':text x0 -4*d '<' ':rL'
ball x1 -5*d 0 'k>':text x0 -5*d '>' ':rL'
define x0 -0.3:define x1 -0.5
ball x1 5*d 'k#.':text x0 5*d '\#.' ':rL'
ball x1 4*d 'k#+':text x0 4*d '\#+' ':rL'
ball x1 3*d 'k#x':text x0 3*d '\#x' ':rL'
ball x1 2*d 'k#*':text x0 2*d '\#*' ':rL'
ball x1 d 'k#s':text x0 d '\#s' ':rL'
ball x1 0 'k#d':text x0 0 '\#d' ':rL'
ball x1 -d 0 'k#o':text x0 -d '\#o' ':rL'
ball x1 -2*d 0 'k#^':text x0 -2*d '\#\^' ':rL'
ball x1 -3*d 0 'k#v':text x0 -3*d '\#v' ':rL'
ball x1 -4*d 0 'k#<':text x0 -4*d '\#<' ':rL'
ball x1 -5*d 0 'k#>':text x0 -5*d '\#>' ':rL'
subplot 3 2 1
define a 0.1:define b 0.4:define c 0.5
line a 1 b 1 'k-A':text c 1 'Style `A` or `A\_`' ':rL'
line a 0.8 b 0.8 'k-V':text c 0.8 'Style `V` or `V\_`' ':rL'
line a 0.6 b 0.6 'k-K':text c 0.6 'Style `K` or `K\_`' ':rL'
line a 0.4 b 0.4 'k-I':text c 0.4 'Style `I` or `I\_`' ':rL'
line a 0.2 b 0.2 'k-D':text c 0.2 'Style `D` or `D\_`' ':rL'
line a 0 b 0 'k-S':text c 0 'Style `S` or `S\_`' ':rL'
line a -0.2 b -0.2 'k-O':text c -0.2 'Style `O` or `O\_`' ':rL'
line a -0.4 b -0.4 'k-T':text c -0.4 'Style `T` or `T\_`' ':rL'
line a -0.6 b -0.6 'k-_':text c -0.6 'Style `\_` or none' ':rL'
line a -0.8 b -0.8 'k-AS':text c -0.8 'Style `AS`' ':rL'
line a -1 b -1 'k-_A':text c -1 'Style `\_A`' ':rL'
define a -1:define b -0.7:define c -0.6
line a 1 b 1 'kAA':text c 1 'Style `AA`' ':rL'
line a 0.8 b 0.8 'kVV':text c 0.8 'Style `VV`' ':rL'
line a 0.6 b 0.6 'kKK':text c 0.6 'Style `KK`' ':rL'
line a 0.4 b 0.4 'kII':text c 0.4 'Style `II`' ':rL'
line a 0.2 b 0.2 'kDD':text c 0.2 'Style `DD`' ':rL'
line a 0 b 0 'kSS':text c 0 'Style `SS`' ':rL'
line a -0.2 b -0.2 'kOO':text c -0.2 'Style `OO`' ':rL'
line a -0.4 b -0.4 'kTT':text c -0.4 'Style `TT`' ':rL'
line a -0.6 b -0.6 'k-__':text c -0.6 'Style `\_\_`' ':rL'
line a -0.8 b -0.8 'k-VA':text c -0.8 'Style `VA`' ':rL'
line a -1 b -1 'k-AV':text c -1 'Style `AV`' ':rL'
subplot 3 2 2
#LENUQ
facez -1 -1 0 0.4 0.3 'L#':text -0.8 -0.9 'L' 'w:C' -1.4
facez -0.6 -1 0 0.4 0.3 'E#':text -0.4 -0.9 'E' 'w:C' -1.4
facez -0.2 -1 0 0.4 0.3 'N#':text 0 -0.9 'N' 'w:C' -1.4
facez 0.2 -1 0 0.4 0.3 'U#':text 0.4 -0.9 'U' 'w:C' -1.4
facez 0.6 -1 0 0.4 0.3 'Q#':text 0.8 -0.9 'Q' 'w:C' -1.4
#lenuq
facez -1 -0.7 0 0.4 0.3 'l#':text -0.8 -0.6 'l' 'k:C' -1.4
facez -0.6 -0.7 0 0.4 0.3 'e#':text -0.4 -0.6 'e' 'k:C' -1.4
facez -0.2 -0.7 0 0.4 0.3 'n#':text 0 -0.6 'n' 'k:C' -1.4
facez 0.2 -0.7 0 0.4 0.3 'u#':text 0.4 -0.6 'u' 'k:C' -1.4
facez 0.6 -0.7 0 0.4 0.3 'q#':text 0.8 -0.6 'q' 'k:C' -1.4
#CMYkP
facez -1 -0.4 0 0.4 0.3 'C#':text -0.8 -0.3 'C' 'w:C' -1.4
facez -0.6 -0.4 0 0.4 0.3 'M#':text -0.4 -0.3 'M' 'w:C' -1.4
facez -0.2 -0.4 0 0.4 0.3 'Y#':text 0 -0.3 'Y' 'w:C' -1.4
facez 0.2 -0.4 0 0.4 0.3 'k#':text 0.4 -0.3 'k' 'w:C' -1.4
facez 0.6 -0.4 0 0.4 0.3 'P#':text 0.8 -0.3 'P' 'w:C' -1.4
#cmywp
facez -1 -0.1 0 0.4 0.3 'c#':text -0.8 0 'c' 'k:C' -1.4
facez -0.6 -0.1 0 0.4 0.3 'm#':text -0.4 0 'm' 'k:C' -1.4
facez -0.2 -0.1 0 0.4 0.3 'y#':text 0 0 'y' 'k:C' -1.4
facez 0.2 -0.1 0 0.4 0.3 'w#':text 0.4 0 'w' 'k:C' -1.4
facez 0.6 -0.1 0 0.4 0.3 'p#':text 0.8 0 'p' 'k:C' -1.4
#BGRHW
facez -1 0.2 0 0.4 0.3 'B#':text -0.8 0.3 'B' 'w:C' -1.4
facez -0.6 0.2 0 0.4 0.3 'G#':text -0.4 0.3 'G' 'w:C' -1.4
facez -0.2 0.2 0 0.4 0.3 'R#':text 0 0.3 'R' 'w:C' -1.4
facez 0.2 0.2 0 0.4 0.3 'H#':text 0.4 0.3 'H' 'w:C' -1.4
facez 0.6 0.2 0 0.4 0.3 'W#':text 0.8 0.3 'W' 'w:C' -1.4
#bgrhw
facez -1 0.5 0 0.4 0.3 'b#':text -0.8 0.6 'b' 'k:C' -1.4
facez -0.6 0.5 0 0.4 0.3 'g#':text -0.4 0.6 'g' 'k:C' -1.4
facez -0.2 0.5 0 0.4 0.3 'r#':text 0 0.6 'r' 'k:C' -1.4
facez 0.2 0.5 0 0.4 0.3 'h#':text 0.4 0.6 'h' 'k:C' -1.4
facez 0.6 0.5 0 0.4 0.3 'w#':text 0.8 0.6 'w' 'k:C' -1.4
#brighted
facez -1 0.8 0 0.4 0.3 '{r1}#':text -0.8 0.9 '\{r1\}' 'w:C' -1.4
facez -0.6 0.8 0 0.4 0.3 '{r3}#':text -0.4 0.9 '\{r3\}' 'w:C' -1.4
facez -0.2 0.8 0 0.4 0.3 '{r5}#':text 0 0.9 '\{r5\}' 'k:C' -1.4
facez 0.2 0.8 0 0.4 0.3 '{r7}#':text 0.4 0.9 '\{r7\}' 'k:C' -1.4
facez 0.6 0.8 0 0.4 0.3 '{r9}#':text 0.8 0.9 '\{r9\}' 'k:C' -1.4
# HEX
facez -1 -1.3 0 1 0.3 '{xff9966}#':text -0.5 -1.2 '\{xff9966\}' 'k:C' -1.4
facez 0 -1.3 0 1 0.3 '{x83CAFF}#':text 0.5 -1.2 '\{x83caff\}' 'k:C' -1.4
subplot 3 2 3
for $i 0 9
line -1 0.2*$i-1 1 0.2*$i-1 'r','0'+$i
text 1.05 0.2*$i-1 '0'+$i ':L'
next
subplot 3 2 4:title 'TriPlot sample':rotate 50 60
list tt 0 1 2 | 0 1 3 | 0 2 3 | 1 2 3
list xt -1 1 0 0:list yt -1 -1 1 0:list zt -1 -1 -1 1:light on
triplot tt xt yt zt 'b':triplot tt xt yt zt 'k#'
subplot 3 2 5:new r 4 'i+1':ranges 1 4 1 4
axis:mark r r 's':plot r 'b'
C++ code:
void smgl_quality5(mglGraph *gr) // test file export
{
gr->SetQuality(5); all_prims(gr);
}
Next: quality8 sample, Previous: quality5 sample, Up: All samples [Contents][Index]
10.97 Sample ‘quality6’
Show all kind of primitives in quality=6.
MGL code:
quality 6
subplot 3 2 0:define y 0.95
define d 0.3:define x0 0.2:define x1 0.5:define x2 0.6
line x0 1-0*d x1 1-0*d 'k-':text x2 y-0*d 'Solid `-`' ':rL'
line x0 1-1*d x1 1-1*d 'k|':text x2 y-1*d 'Long Dash `|`' ':rL'
line x0 1-2*d x1 1-2*d 'k;':text x2 y-2*d 'Dash 1;`' ':rL'
line x0 1-3*d x1 1-3*d 'k=':text x2 y-3*d 'Small dash `=`' ':rL'
line x0 1-4*d x1 1-4*d 'kj':text x2 y-4*d 'Dash-dot `j`' ':rL'
line x0 1-5*d x1 1-5*d 'ki':text x2 y-5*d 'Small dash-dot `i`' ':rL'
line x0 1-6*d x1 1-6*d 'k:':text x2 y-6*d 'Dots `:`' ':rL'
line x0 1-7*d x1 1-7*d 'k ':text x2 y-7*d 'None ``' ':rL'
define d 0.25:define x0 -0.8:define x1 -1:define x2 -0.05
ball x1 5*d 'k.':text x0 5*d '.' ':rL'
ball x1 4*d 'k+':text x0 4*d '+' ':rL'
ball x1 3*d 'kx':text x0 3*d 'x' ':rL'
ball x1 2*d 'k*':text x0 2*d '*' ':rL'
ball x1 d 'ks':text x0 d 's' ':rL'
ball x1 0 'kd':text x0 0 'd' ':rL'
ball x1 -d 0 'ko':text x0 y-d 'o' ':rL'
ball x1 -2*d 0 'k^':text x0 -2*d '\^' ':rL'
ball x1 -3*d 0 'kv':text x0 -3*d 'v' ':rL'
ball x1 -4*d 0 'k<':text x0 -4*d '<' ':rL'
ball x1 -5*d 0 'k>':text x0 -5*d '>' ':rL'
define x0 -0.3:define x1 -0.5
ball x1 5*d 'k#.':text x0 5*d '\#.' ':rL'
ball x1 4*d 'k#+':text x0 4*d '\#+' ':rL'
ball x1 3*d 'k#x':text x0 3*d '\#x' ':rL'
ball x1 2*d 'k#*':text x0 2*d '\#*' ':rL'
ball x1 d 'k#s':text x0 d '\#s' ':rL'
ball x1 0 'k#d':text x0 0 '\#d' ':rL'
ball x1 -d 0 'k#o':text x0 -d '\#o' ':rL'
ball x1 -2*d 0 'k#^':text x0 -2*d '\#\^' ':rL'
ball x1 -3*d 0 'k#v':text x0 -3*d '\#v' ':rL'
ball x1 -4*d 0 'k#<':text x0 -4*d '\#<' ':rL'
ball x1 -5*d 0 'k#>':text x0 -5*d '\#>' ':rL'
subplot 3 2 1
define a 0.1:define b 0.4:define c 0.5
line a 1 b 1 'k-A':text c 1 'Style `A` or `A\_`' ':rL'
line a 0.8 b 0.8 'k-V':text c 0.8 'Style `V` or `V\_`' ':rL'
line a 0.6 b 0.6 'k-K':text c 0.6 'Style `K` or `K\_`' ':rL'
line a 0.4 b 0.4 'k-I':text c 0.4 'Style `I` or `I\_`' ':rL'
line a 0.2 b 0.2 'k-D':text c 0.2 'Style `D` or `D\_`' ':rL'
line a 0 b 0 'k-S':text c 0 'Style `S` or `S\_`' ':rL'
line a -0.2 b -0.2 'k-O':text c -0.2 'Style `O` or `O\_`' ':rL'
line a -0.4 b -0.4 'k-T':text c -0.4 'Style `T` or `T\_`' ':rL'
line a -0.6 b -0.6 'k-_':text c -0.6 'Style `\_` or none' ':rL'
line a -0.8 b -0.8 'k-AS':text c -0.8 'Style `AS`' ':rL'
line a -1 b -1 'k-_A':text c -1 'Style `\_A`' ':rL'
define a -1:define b -0.7:define c -0.6
line a 1 b 1 'kAA':text c 1 'Style `AA`' ':rL'
line a 0.8 b 0.8 'kVV':text c 0.8 'Style `VV`' ':rL'
line a 0.6 b 0.6 'kKK':text c 0.6 'Style `KK`' ':rL'
line a 0.4 b 0.4 'kII':text c 0.4 'Style `II`' ':rL'
line a 0.2 b 0.2 'kDD':text c 0.2 'Style `DD`' ':rL'
line a 0 b 0 'kSS':text c 0 'Style `SS`' ':rL'
line a -0.2 b -0.2 'kOO':text c -0.2 'Style `OO`' ':rL'
line a -0.4 b -0.4 'kTT':text c -0.4 'Style `TT`' ':rL'
line a -0.6 b -0.6 'k-__':text c -0.6 'Style `\_\_`' ':rL'
line a -0.8 b -0.8 'k-VA':text c -0.8 'Style `VA`' ':rL'
line a -1 b -1 'k-AV':text c -1 'Style `AV`' ':rL'
subplot 3 2 2
#LENUQ
facez -1 -1 0 0.4 0.3 'L#':text -0.8 -0.9 'L' 'w:C' -1.4
facez -0.6 -1 0 0.4 0.3 'E#':text -0.4 -0.9 'E' 'w:C' -1.4
facez -0.2 -1 0 0.4 0.3 'N#':text 0 -0.9 'N' 'w:C' -1.4
facez 0.2 -1 0 0.4 0.3 'U#':text 0.4 -0.9 'U' 'w:C' -1.4
facez 0.6 -1 0 0.4 0.3 'Q#':text 0.8 -0.9 'Q' 'w:C' -1.4
#lenuq
facez -1 -0.7 0 0.4 0.3 'l#':text -0.8 -0.6 'l' 'k:C' -1.4
facez -0.6 -0.7 0 0.4 0.3 'e#':text -0.4 -0.6 'e' 'k:C' -1.4
facez -0.2 -0.7 0 0.4 0.3 'n#':text 0 -0.6 'n' 'k:C' -1.4
facez 0.2 -0.7 0 0.4 0.3 'u#':text 0.4 -0.6 'u' 'k:C' -1.4
facez 0.6 -0.7 0 0.4 0.3 'q#':text 0.8 -0.6 'q' 'k:C' -1.4
#CMYkP
facez -1 -0.4 0 0.4 0.3 'C#':text -0.8 -0.3 'C' 'w:C' -1.4
facez -0.6 -0.4 0 0.4 0.3 'M#':text -0.4 -0.3 'M' 'w:C' -1.4
facez -0.2 -0.4 0 0.4 0.3 'Y#':text 0 -0.3 'Y' 'w:C' -1.4
facez 0.2 -0.4 0 0.4 0.3 'k#':text 0.4 -0.3 'k' 'w:C' -1.4
facez 0.6 -0.4 0 0.4 0.3 'P#':text 0.8 -0.3 'P' 'w:C' -1.4
#cmywp
facez -1 -0.1 0 0.4 0.3 'c#':text -0.8 0 'c' 'k:C' -1.4
facez -0.6 -0.1 0 0.4 0.3 'm#':text -0.4 0 'm' 'k:C' -1.4
facez -0.2 -0.1 0 0.4 0.3 'y#':text 0 0 'y' 'k:C' -1.4
facez 0.2 -0.1 0 0.4 0.3 'w#':text 0.4 0 'w' 'k:C' -1.4
facez 0.6 -0.1 0 0.4 0.3 'p#':text 0.8 0 'p' 'k:C' -1.4
#BGRHW
facez -1 0.2 0 0.4 0.3 'B#':text -0.8 0.3 'B' 'w:C' -1.4
facez -0.6 0.2 0 0.4 0.3 'G#':text -0.4 0.3 'G' 'w:C' -1.4
facez -0.2 0.2 0 0.4 0.3 'R#':text 0 0.3 'R' 'w:C' -1.4
facez 0.2 0.2 0 0.4 0.3 'H#':text 0.4 0.3 'H' 'w:C' -1.4
facez 0.6 0.2 0 0.4 0.3 'W#':text 0.8 0.3 'W' 'w:C' -1.4
#bgrhw
facez -1 0.5 0 0.4 0.3 'b#':text -0.8 0.6 'b' 'k:C' -1.4
facez -0.6 0.5 0 0.4 0.3 'g#':text -0.4 0.6 'g' 'k:C' -1.4
facez -0.2 0.5 0 0.4 0.3 'r#':text 0 0.6 'r' 'k:C' -1.4
facez 0.2 0.5 0 0.4 0.3 'h#':text 0.4 0.6 'h' 'k:C' -1.4
facez 0.6 0.5 0 0.4 0.3 'w#':text 0.8 0.6 'w' 'k:C' -1.4
#brighted
facez -1 0.8 0 0.4 0.3 '{r1}#':text -0.8 0.9 '\{r1\}' 'w:C' -1.4
facez -0.6 0.8 0 0.4 0.3 '{r3}#':text -0.4 0.9 '\{r3\}' 'w:C' -1.4
facez -0.2 0.8 0 0.4 0.3 '{r5}#':text 0 0.9 '\{r5\}' 'k:C' -1.4
facez 0.2 0.8 0 0.4 0.3 '{r7}#':text 0.4 0.9 '\{r7\}' 'k:C' -1.4
facez 0.6 0.8 0 0.4 0.3 '{r9}#':text 0.8 0.9 '\{r9\}' 'k:C' -1.4
# HEX
facez -1 -1.3 0 1 0.3 '{xff9966}#':text -0.5 -1.2 '\{xff9966\}' 'k:C' -1.4
facez 0 -1.3 0 1 0.3 '{x83CAFF}#':text 0.5 -1.2 '\{x83caff\}' 'k:C' -1.4
subplot 3 2 3
for $i 0 9
line -1 0.2*$i-1 1 0.2*$i-1 'r','0'+$i
text 1.05 0.2*$i-1 '0'+$i ':L'
next
subplot 3 2 4:title 'TriPlot sample':rotate 50 60
list tt 0 1 2 | 0 1 3 | 0 2 3 | 1 2 3
list xt -1 1 0 0:list yt -1 -1 1 0:list zt -1 -1 -1 1:light on
triplot tt xt yt zt 'b':triplot tt xt yt zt 'k#'
subplot 3 2 5:new r 4 'i+1':ranges 1 4 1 4
axis:mark r r 's':plot r 'b'
C++ code:
void smgl_quality6(mglGraph *gr) // test file export
{
gr->SetQuality(6); all_prims(gr);
}
Next: radar sample, Previous: quality6 sample, Up: All samples [Contents][Index]
10.98 Sample ‘quality8’
Show all kind of primitives in quality=8.
MGL code:
quality 8
subplot 3 2 0:define y 0.95
define d 0.3:define x0 0.2:define x1 0.5:define x2 0.6
line x0 1-0*d x1 1-0*d 'k-':text x2 y-0*d 'Solid `-`' ':rL'
line x0 1-1*d x1 1-1*d 'k|':text x2 y-1*d 'Long Dash `|`' ':rL'
line x0 1-2*d x1 1-2*d 'k;':text x2 y-2*d 'Dash 1;`' ':rL'
line x0 1-3*d x1 1-3*d 'k=':text x2 y-3*d 'Small dash `=`' ':rL'
line x0 1-4*d x1 1-4*d 'kj':text x2 y-4*d 'Dash-dot `j`' ':rL'
line x0 1-5*d x1 1-5*d 'ki':text x2 y-5*d 'Small dash-dot `i`' ':rL'
line x0 1-6*d x1 1-6*d 'k:':text x2 y-6*d 'Dots `:`' ':rL'
line x0 1-7*d x1 1-7*d 'k ':text x2 y-7*d 'None ``' ':rL'
define d 0.25:define x0 -0.8:define x1 -1:define x2 -0.05
ball x1 5*d 'k.':text x0 5*d '.' ':rL'
ball x1 4*d 'k+':text x0 4*d '+' ':rL'
ball x1 3*d 'kx':text x0 3*d 'x' ':rL'
ball x1 2*d 'k*':text x0 2*d '*' ':rL'
ball x1 d 'ks':text x0 d 's' ':rL'
ball x1 0 'kd':text x0 0 'd' ':rL'
ball x1 -d 0 'ko':text x0 y-d 'o' ':rL'
ball x1 -2*d 0 'k^':text x0 -2*d '\^' ':rL'
ball x1 -3*d 0 'kv':text x0 -3*d 'v' ':rL'
ball x1 -4*d 0 'k<':text x0 -4*d '<' ':rL'
ball x1 -5*d 0 'k>':text x0 -5*d '>' ':rL'
define x0 -0.3:define x1 -0.5
ball x1 5*d 'k#.':text x0 5*d '\#.' ':rL'
ball x1 4*d 'k#+':text x0 4*d '\#+' ':rL'
ball x1 3*d 'k#x':text x0 3*d '\#x' ':rL'
ball x1 2*d 'k#*':text x0 2*d '\#*' ':rL'
ball x1 d 'k#s':text x0 d '\#s' ':rL'
ball x1 0 'k#d':text x0 0 '\#d' ':rL'
ball x1 -d 0 'k#o':text x0 -d '\#o' ':rL'
ball x1 -2*d 0 'k#^':text x0 -2*d '\#\^' ':rL'
ball x1 -3*d 0 'k#v':text x0 -3*d '\#v' ':rL'
ball x1 -4*d 0 'k#<':text x0 -4*d '\#<' ':rL'
ball x1 -5*d 0 'k#>':text x0 -5*d '\#>' ':rL'
subplot 3 2 1
define a 0.1:define b 0.4:define c 0.5
line a 1 b 1 'k-A':text c 1 'Style `A` or `A\_`' ':rL'
line a 0.8 b 0.8 'k-V':text c 0.8 'Style `V` or `V\_`' ':rL'
line a 0.6 b 0.6 'k-K':text c 0.6 'Style `K` or `K\_`' ':rL'
line a 0.4 b 0.4 'k-I':text c 0.4 'Style `I` or `I\_`' ':rL'
line a 0.2 b 0.2 'k-D':text c 0.2 'Style `D` or `D\_`' ':rL'
line a 0 b 0 'k-S':text c 0 'Style `S` or `S\_`' ':rL'
line a -0.2 b -0.2 'k-O':text c -0.2 'Style `O` or `O\_`' ':rL'
line a -0.4 b -0.4 'k-T':text c -0.4 'Style `T` or `T\_`' ':rL'
line a -0.6 b -0.6 'k-_':text c -0.6 'Style `\_` or none' ':rL'
line a -0.8 b -0.8 'k-AS':text c -0.8 'Style `AS`' ':rL'
line a -1 b -1 'k-_A':text c -1 'Style `\_A`' ':rL'
define a -1:define b -0.7:define c -0.6
line a 1 b 1 'kAA':text c 1 'Style `AA`' ':rL'
line a 0.8 b 0.8 'kVV':text c 0.8 'Style `VV`' ':rL'
line a 0.6 b 0.6 'kKK':text c 0.6 'Style `KK`' ':rL'
line a 0.4 b 0.4 'kII':text c 0.4 'Style `II`' ':rL'
line a 0.2 b 0.2 'kDD':text c 0.2 'Style `DD`' ':rL'
line a 0 b 0 'kSS':text c 0 'Style `SS`' ':rL'
line a -0.2 b -0.2 'kOO':text c -0.2 'Style `OO`' ':rL'
line a -0.4 b -0.4 'kTT':text c -0.4 'Style `TT`' ':rL'
line a -0.6 b -0.6 'k-__':text c -0.6 'Style `\_\_`' ':rL'
line a -0.8 b -0.8 'k-VA':text c -0.8 'Style `VA`' ':rL'
line a -1 b -1 'k-AV':text c -1 'Style `AV`' ':rL'
subplot 3 2 2
#LENUQ
facez -1 -1 0 0.4 0.3 'L#':text -0.8 -0.9 'L' 'w:C' -1.4
facez -0.6 -1 0 0.4 0.3 'E#':text -0.4 -0.9 'E' 'w:C' -1.4
facez -0.2 -1 0 0.4 0.3 'N#':text 0 -0.9 'N' 'w:C' -1.4
facez 0.2 -1 0 0.4 0.3 'U#':text 0.4 -0.9 'U' 'w:C' -1.4
facez 0.6 -1 0 0.4 0.3 'Q#':text 0.8 -0.9 'Q' 'w:C' -1.4
#lenuq
facez -1 -0.7 0 0.4 0.3 'l#':text -0.8 -0.6 'l' 'k:C' -1.4
facez -0.6 -0.7 0 0.4 0.3 'e#':text -0.4 -0.6 'e' 'k:C' -1.4
facez -0.2 -0.7 0 0.4 0.3 'n#':text 0 -0.6 'n' 'k:C' -1.4
facez 0.2 -0.7 0 0.4 0.3 'u#':text 0.4 -0.6 'u' 'k:C' -1.4
facez 0.6 -0.7 0 0.4 0.3 'q#':text 0.8 -0.6 'q' 'k:C' -1.4
#CMYkP
facez -1 -0.4 0 0.4 0.3 'C#':text -0.8 -0.3 'C' 'w:C' -1.4
facez -0.6 -0.4 0 0.4 0.3 'M#':text -0.4 -0.3 'M' 'w:C' -1.4
facez -0.2 -0.4 0 0.4 0.3 'Y#':text 0 -0.3 'Y' 'w:C' -1.4
facez 0.2 -0.4 0 0.4 0.3 'k#':text 0.4 -0.3 'k' 'w:C' -1.4
facez 0.6 -0.4 0 0.4 0.3 'P#':text 0.8 -0.3 'P' 'w:C' -1.4
#cmywp
facez -1 -0.1 0 0.4 0.3 'c#':text -0.8 0 'c' 'k:C' -1.4
facez -0.6 -0.1 0 0.4 0.3 'm#':text -0.4 0 'm' 'k:C' -1.4
facez -0.2 -0.1 0 0.4 0.3 'y#':text 0 0 'y' 'k:C' -1.4
facez 0.2 -0.1 0 0.4 0.3 'w#':text 0.4 0 'w' 'k:C' -1.4
facez 0.6 -0.1 0 0.4 0.3 'p#':text 0.8 0 'p' 'k:C' -1.4
#BGRHW
facez -1 0.2 0 0.4 0.3 'B#':text -0.8 0.3 'B' 'w:C' -1.4
facez -0.6 0.2 0 0.4 0.3 'G#':text -0.4 0.3 'G' 'w:C' -1.4
facez -0.2 0.2 0 0.4 0.3 'R#':text 0 0.3 'R' 'w:C' -1.4
facez 0.2 0.2 0 0.4 0.3 'H#':text 0.4 0.3 'H' 'w:C' -1.4
facez 0.6 0.2 0 0.4 0.3 'W#':text 0.8 0.3 'W' 'w:C' -1.4
#bgrhw
facez -1 0.5 0 0.4 0.3 'b#':text -0.8 0.6 'b' 'k:C' -1.4
facez -0.6 0.5 0 0.4 0.3 'g#':text -0.4 0.6 'g' 'k:C' -1.4
facez -0.2 0.5 0 0.4 0.3 'r#':text 0 0.6 'r' 'k:C' -1.4
facez 0.2 0.5 0 0.4 0.3 'h#':text 0.4 0.6 'h' 'k:C' -1.4
facez 0.6 0.5 0 0.4 0.3 'w#':text 0.8 0.6 'w' 'k:C' -1.4
#brighted
facez -1 0.8 0 0.4 0.3 '{r1}#':text -0.8 0.9 '\{r1\}' 'w:C' -1.4
facez -0.6 0.8 0 0.4 0.3 '{r3}#':text -0.4 0.9 '\{r3\}' 'w:C' -1.4
facez -0.2 0.8 0 0.4 0.3 '{r5}#':text 0 0.9 '\{r5\}' 'k:C' -1.4
facez 0.2 0.8 0 0.4 0.3 '{r7}#':text 0.4 0.9 '\{r7\}' 'k:C' -1.4
facez 0.6 0.8 0 0.4 0.3 '{r9}#':text 0.8 0.9 '\{r9\}' 'k:C' -1.4
# HEX
facez -1 -1.3 0 1 0.3 '{xff9966}#':text -0.5 -1.2 '\{xff9966\}' 'k:C' -1.4
facez 0 -1.3 0 1 0.3 '{x83CAFF}#':text 0.5 -1.2 '\{x83caff\}' 'k:C' -1.4
subplot 3 2 3
for $i 0 9
line -1 0.2*$i-1 1 0.2*$i-1 'r','0'+$i
text 1.05 0.2*$i-1 '0'+$i ':L'
next
subplot 3 2 4:title 'TriPlot sample':rotate 50 60
list tt 0 1 2 | 0 1 3 | 0 2 3 | 1 2 3
list xt -1 1 0 0:list yt -1 -1 1 0:list zt -1 -1 -1 1:light on
triplot tt xt yt zt 'b':triplot tt xt yt zt 'k#'
subplot 3 2 5:new r 4 'i+1':ranges 1 4 1 4
axis:mark r r 's':plot r 'b'
C++ code:
void smgl_quality8(mglGraph *gr) // test file export
{
gr->SetQuality(8); all_prims(gr);
}
Next: refill sample, Previous: quality8 sample, Up: All samples [Contents][Index]
10.99 Sample ‘radar’
The radar plot is variant of plot, which make plot in polar coordinates and draw radial rays in point directions. If you just need a plot in polar coordinates then I recommend to use Curvilinear coordinates or plot in parametric form with x=r*cos(fi); y=r*sin(fi);.
MGL code:
new yr 10 3 '0.4*sin(pi*(x+1.5+y/2)+0.1*rnd)' subplot 1 1 0 '':title 'Radar plot (with grid, "\#")':radar yr '#'
C++ code:
void smgl_radar(mglGraph *gr)
{
mglData yr(10,3); yr.Modify("0.4*sin(pi*(2*x+y))+0.1*rnd");
if(big!=3) { gr->SubPlot(1,1,0,""); gr->Title("Radar plot (with grid, '\\#')"); }
gr->Radar(yr,"#");
}
Next: region sample, Previous: radar sample, Up: All samples [Contents][Index]
10.100 Sample ‘refill’
Example of refill and gspline.
MGL code:
new x 10 '0.5+rnd':cumsum x 'x':norm x -1 1 copy y sin(pi*x)/1.5 subplot 2 2 0 '<_':title 'Refill sample' box:axis:plot x y 'o ':fplot 'sin(pi*x)/1.5' 'B:' new r 100:refill r x y:plot r 'r' subplot 2 2 1 '<_':title 'Global spline' box:axis:plot x y 'o ':fplot 'sin(pi*x)/1.5' 'B:' new r 100:gspline r x y:plot r 'r' new y 10 '0.5+rnd':cumsum y 'x':norm y -1 1 copy xx x:extend xx 10 copy yy y:extend yy 10:transpose yy copy z sin(pi*xx*yy)/1.5 alpha on:light on subplot 2 2 2:title '2d regular':rotate 40 60 box:axis:mesh xx yy z 'k' new rr 100 100:refill rr x y z:surf rr new xx 10 10 '(x+1)/2*cos(y*pi/2-1)':new yy 10 10 '(x+1)/2*sin(y*pi/2-1)' copy z sin(pi*xx*yy)/1.5 subplot 2 2 3:title '2d non-regular':rotate 40 60 box:axis:plot xx yy z 'ko ' new rr 100 100:refill rr xx yy z:surf rr
C++ code:
void smgl_refill(mglGraph *gr)
{
mglData x(10), y(10), r(100);
x.Modify("0.5+rnd"); x.CumSum("x"); x.Norm(-1,1);
y.Modify("sin(pi*v)/1.5",x);
if(big!=3) { gr->SubPlot(2,2,0,"<_"); gr->Title("Refill sample"); }
gr->Axis(); gr->Box(); gr->Plot(x,y,"o ");
gr->Refill(r,x,y); // or you can use r.Refill(x,y,-1,1);
gr->Plot(r,"r"); gr->FPlot("sin(pi*x)/1.5","B:");
if(big==3) return;
gr->SubPlot(2,2,1,"<_"); gr->Title("Global spline");
gr->Axis(); gr->Box(); gr->Plot(x,y,"o ");
r.RefillGS(x,y,-1,1); gr->Plot(r,"r");
gr->FPlot("sin(pi*x)/1.5","B:");
gr->Alpha(true); gr->Light(true);
mglData z(10,10), xx(10,10), yy(10,10), rr(100,100);
y.Modify("0.5+rnd"); y.CumSum("x"); y.Norm(-1,1);
for(int i=0;i<10;i++) for(int j=0;j<10;j++)
z.a[i+10*j] = sin(M_PI*x.a[i]*y.a[j])/1.5;
gr->SubPlot(2,2,2); gr->Title("2d regular"); gr->Rotate(40,60);
gr->Axis(); gr->Box(); gr->Mesh(x,y,z,"k");
gr->Refill(rr,x,y,z); gr->Surf(rr);
gr->Fill(xx,"(x+1)/2*cos(y*pi/2-1)");
gr->Fill(yy,"(x+1)/2*sin(y*pi/2-1)");
for(int i=0;i<10*10;i++)
z.a[i] = sin(M_PI*xx.a[i]*yy.a[i])/1.5;
gr->SubPlot(2,2,3); gr->Title("2d non-regular"); gr->Rotate(40,60);
gr->Axis(); gr->Box(); gr->Plot(xx,yy,z,"ko ");
gr->Refill(rr,xx,yy,z); gr->Surf(rr);
}
Next: scanfile sample, Previous: refill sample, Up: All samples [Contents][Index]
10.101 Sample ‘region’
Function region fill the area between 2 curves. It support gradient filling if 2 colors per curve is specified. Also it can fill only the region y1<y<y2 if style ‘i’ is used.
MGL code:
call 'prepare1d' copy y1 y(:,1):copy y2 y(:,2) subplot 2 2 0 '':title 'Region plot (default)':box:region y1 y2:plot y1 'k2':plot y2 'k2' subplot 2 2 1 '':title '2 colors':box:region y1 y2 'yr':plot y1 'k2':plot y2 'k2' subplot 2 2 2 '':title '"i" style':box:region y1 y2 'ir':plot y1 'k2':plot y2 'k2' subplot 2 2 3 '^_':title '3d variant':rotate 40 60:box new x1 100 'sin(pi*x)':new y1 100 'cos(pi*x)':new z 100 'x' new x2 100 'sin(pi*x+pi/3)':new y2 100 'cos(pi*x+pi/3)' plot x1 y1 z 'r2':plot x2 y2 z 'b2' region x1 y1 z x2 y2 z 'cmy!'
C++ code:
void smgl_region(mglGraph *gr)
{
mglData y; mgls_prepare1d(&y);
mglData y1 = y.SubData(-1,1), y2 = y.SubData(-1,2); gr->SetOrigin(0,0,0);
if(big!=3) { gr->SubPlot(2,2,0,""); gr->Title("Region plot (default)"); }
gr->Box(); gr->Region(y1,y2); gr->Plot(y1,"k2"); gr->Plot(y2,"k2");
if(big==3) return;
gr->SubPlot(2,2,1,""); gr->Title("2 colors"); gr->Box(); gr->Region(y1,y2,"yr"); gr->Plot(y1,"k2"); gr->Plot(y2,"k2");
gr->SubPlot(2,2,2,""); gr->Title("'i' style"); gr->Box(); gr->Region(y1,y2,"ir"); gr->Plot(y1,"k2"); gr->Plot(y2,"k2");
gr->SubPlot(2,2,3,"^_"); gr->Title("3d variant"); gr->Rotate(40,60); gr->Box();
gr->Fill(y1,"cos(pi*x)"); gr->Fill(y2,"cos(pi*x+pi/3)");
mglData x1(y1.nx), x2(y1.nx), z(y1.nx);
gr->Fill(x1,"sin(pi*x)"); gr->Fill(x2,"sin(pi*x+pi/3)"); gr->Fill(z,"x");
gr->Plot(x1,y1,z,"r2"); gr->Plot(x2,y2,z,"b2");
gr->Region(x1,y1,z,x2,y2,z,"cmy!");
}
Next: schemes sample, Previous: region sample, Up: All samples [Contents][Index]
10.102 Sample ‘scanfile’
Example of scanfile for reading ’named’ data.
MGL code:
subplot 1 1 0 '<_':title 'Save and scanfile sample' list a 1 -1 0 save 'This is test: 0 -> ',a(0),' q' 'test.txt' 'w' save 'This is test: 1 -> ',a(1),' q' 'test.txt' save 'This is test: 2 -> ',a(2),' q' 'test.txt' scanfile a 'test.txt' 'This is test: %g -> %g' ranges a(0) a(1):axis:plot a(0) a(1) 'o'
C++ code:
void smgl_scanfile(mglGraph *gr)
{
gr->SubPlot(1,1,0,"<_");
if(big!=3) gr->Title("Save and scanfile sample");
FILE *fp=fopen("test.txt","w");
fprintf(fp,"This is test: 0 -> 1 q\n");
fprintf(fp,"This is test: 1 -> -1 q\n");
fprintf(fp,"This is test: 2 -> 0 q\n");
fclose(fp);
mglData a;
a.ScanFile("test.txt","This is test: %g -> %g");
gr->SetRanges(a.SubData(0), a.SubData(1));
gr->Axis(); gr->Plot(a.SubData(0),a.SubData(1),"o");
}
Next: section sample, Previous: scanfile sample, Up: All samples [Contents][Index]
10.103 Sample ‘schemes’
Example of popular color schemes.
MGL code:
new x 100 100 'x':new y 100 100 'y'
call 'sch' 0 'kw'
call 'sch' 1 '%gbrw'
call 'sch' 2 'kHCcw'
call 'sch' 3 'kBbcw'
call 'sch' 4 'kRryw'
call 'sch' 5 'kGgew'
call 'sch' 6 'BbwrR'
call 'sch' 7 'BbwgG'
call 'sch' 8 'GgwmM'
call 'sch' 9 'UuwqR'
call 'sch' 10 'QqwcC'
call 'sch' 11 'CcwyY'
call 'sch' 12 'bcwyr'
call 'sch' 13 'bwr'
call 'sch' 14 'wUrqy'
call 'sch' 15 'UbcyqR'
call 'sch' 16 'BbcyrR'
call 'sch' 17 'bgr'
call 'sch' 18 'BbcyrR|'
call 'sch' 19 'b{g,0.3}r'
stop
func 'sch' 2
subplot 2 10 $1 '<>_^' 0.2 0:surfa x y $2
text 0.07+0.5*mod($1,2) 0.92-0.1*int($1/2) $2 'A'
return
C++ code:
void smgl_schemes(mglGraph *gr) // Color table
{
mglData a(256,2), b(256,2); a.Fill(-1,1); b.Fill(-1,1,'y');
gr->SubPlot(2,10,0,NULL,0.2); gr->Dens(a,"kw"); gr->Puts(0.07, 0.92, "kw", "A");
gr->SubPlot(2,10,1,NULL,0.2); gr->SurfA(a,b,"%gbrw"); gr->Puts(0.57, 0.92, "%gbrw", "A");
gr->SubPlot(2,10,2,NULL,0.2); gr->Dens(a,"kHCcw"); gr->Puts(0.07, 0.82, "kHCcw", "A");
gr->SubPlot(2,10,3,NULL,0.2); gr->Dens(a,"kBbcw"); gr->Puts(0.57, 0.82, "kBbcw", "A");
gr->SubPlot(2,10,4,NULL,0.2); gr->Dens(a,"kRryw"); gr->Puts(0.07, 0.72, "kRryw", "A");
gr->SubPlot(2,10,5,NULL,0.2); gr->Dens(a,"kGgew"); gr->Puts(0.57, 0.72, "kGgew", "A");
gr->SubPlot(2,10,6,NULL,0.2); gr->Dens(a,"BbwrR"); gr->Puts(0.07, 0.62, "BbwrR", "A");
gr->SubPlot(2,10,7,NULL,0.2); gr->Dens(a,"BbwgG"); gr->Puts(0.57, 0.62, "BbwgG", "A");
gr->SubPlot(2,10,8,NULL,0.2); gr->Dens(a,"GgwmM"); gr->Puts(0.07, 0.52, "GgwmM", "A");
gr->SubPlot(2,10,9,NULL,0.2); gr->Dens(a,"UuwqR"); gr->Puts(0.57, 0.52, "UuwqR", "A");
gr->SubPlot(2,10,10,NULL,0.2); gr->Dens(a,"QqwcC"); gr->Puts(0.07, 0.42, "QqwcC", "A");
gr->SubPlot(2,10,11,NULL,0.2); gr->Dens(a,"CcwyY"); gr->Puts(0.57, 0.42, "CcwyY", "A");
gr->SubPlot(2,10,12,NULL,0.2); gr->Dens(a,"bcwyr"); gr->Puts(0.07, 0.32, "bcwyr", "A");
gr->SubPlot(2,10,13,NULL,0.2); gr->Dens(a,"bwr"); gr->Puts(0.57, 0.32, "bwr", "A");
gr->SubPlot(2,10,14,NULL,0.2); gr->Dens(a,"wUrqy"); gr->Puts(0.07, 0.22, "wUrqy", "A");
gr->SubPlot(2,10,15,NULL,0.2); gr->Dens(a,"UbcyqR"); gr->Puts(0.57, 0.22, "UbcyqR", "A");
gr->SubPlot(2,10,16,NULL,0.2); gr->Dens(a,"BbcyrR"); gr->Puts(0.07, 0.12, "BbcyrR", "A");
gr->SubPlot(2,10,17,NULL,0.2); gr->Dens(a,"bgr"); gr->Puts(0.57, 0.12, "bgr", "A");
gr->SubPlot(2,10,18,NULL,0.2); gr->Dens(a,"BbcyrR|"); gr->Puts(0.07, 0.02, "BbcyrR|", "A");
gr->SubPlot(2,10,19,NULL,0.2); gr->Dens(a,"b{g,0.3}r"); gr->Puts(0.57, 0.02, "b\\{g,0.3\\}r", "A");
}
Next: several_light sample, Previous: schemes sample, Up: All samples [Contents][Index]
10.104 Sample ‘section’
Example of section to separate data and join it back.
MGL code:
subplot 1 1 0 '<_':title 'Section&Join sample' axis:box:line -1 0 1 0 'h:' # first lets demonstrate 'join' new aa 11 'x^2':new a1 3 '-x':new a2 15 'x^3' join aa a1:join aa a2 # add x-coordinate new xx aa.nx 'x':join aa xx plot aa(:,1) aa(:,0) '2y' # now select 1-st (id=0) section between zeros section b1 aa 0 'x' 0 plot b1(:,1) b1(:,0) 'bo' # next, select 3-d (id=2) section between zeros section b3 aa 2 'x' 0 plot b3(:,1) b3(:,0) 'gs' # finally, select 2-nd (id=-2) section from the end section b4 aa -2 'x' 0 plot b4(:,1) b4(:,0) 'r#o'
C++ code:
void smgl_section(mglGraph *gr)
{
gr->SubPlot(1,1,0,"<_");
if(big!=3) gr->Title("Section&Join sample");
gr->Axis(); gr->Box(); gr->Line(mglPoint(-1,0),mglPoint(1,0),"h:");
// first lets demonstrate 'join'
mglData aa(11), a1(3), a2(15);
gr->Fill(aa,"x^2"); gr->Fill(a1,"-x"); gr->Fill(a2,"x^3");
aa.Join(a1); aa.Join(a2);
// add x-coordinate
mglData xx(aa.nx); gr->Fill(xx,"x"); aa.Join(xx);
gr->Plot(aa.SubData(-1,1), aa.SubData(-1,0), "2y");
// now select 1-st (id=0) section between zeros
mglData b1(aa.Section(0,'x',0));
gr->Plot(b1.SubData(-1,1), b1.SubData(-1,0), "bo");
// next, select 3-d (id=2) section between zeros
mglData b2(aa.Section(2,'x',0));
gr->Plot(b2.SubData(-1,1), b2.SubData(-1,0), "gs");
// finally, select 2-nd (id=-2) section from the end
mglData b3(aa.Section(-2,'x',0));
gr->Plot(b3.SubData(-1,1), b3.SubData(-1,0), "r#o");
}
Next: solve sample, Previous: section sample, Up: All samples [Contents][Index]
10.105 Sample ‘several_light’
Example of using several light sources.
MGL code:
call 'prepare2d' title 'Several light sources':rotate 50 60:light on light 1 0 1 0 'c':light 2 1 0 0 'y':light 3 0 -1 0 'm' box:surf a 'h'
C++ code:
void smgl_several_light(mglGraph *gr) // several light sources
{
mglData a; mgls_prepare2d(&a);
if(big!=3) gr->Title("Several light sources");
gr->Rotate(50,60); gr->Light(true); gr->AddLight(1,mglPoint(0,1,0),'c');
gr->AddLight(2,mglPoint(1,0,0),'y'); gr->AddLight(3,mglPoint(0,-1,0),'m');
gr->Box(); gr->Surf(a,"h");
}
Next: stem sample, Previous: several_light sample, Up: All samples [Contents][Index]
10.106 Sample ‘solve’
Example of solve for root finding.
MGL code:
zrange 0 1 new x 20 30 '(x+2)/3*cos(pi*y)' new y 20 30 '(x+2)/3*sin(pi*y)' new z 20 30 'exp(-6*x^2-2*sin(pi*y)^2)' subplot 2 1 0:title 'Cartesian space':rotate 30 -40 axis 'xyzU':box xlabel 'x':ylabel 'y' origin 1 1:grid 'xy' mesh x y z # section along 'x' direction solve u x 0.5 'x' var v u.nx 0 1 evaluate yy y u v evaluate xx x u v evaluate zz z u v plot xx yy zz 'k2o' # 1st section along 'y' direction solve u1 x -0.5 'y' var v1 u1.nx 0 1 evaluate yy y v1 u1 evaluate xx x v1 u1 evaluate zz z v1 u1 plot xx yy zz 'b2^' # 2nd section along 'y' direction solve u2 x -0.5 'y' u1 evaluate yy y v1 u2 evaluate xx x v1 u2 evaluate zz z v1 u2 plot xx yy zz 'r2v' subplot 2 1 1:title 'Accompanied space' ranges 0 1 0 1:origin 0 0 axis:box:xlabel 'i':ylabel 'j':grid2 z 'h' plot u v 'k2o':line 0.4 0.5 0.8 0.5 'kA' plot v1 u1 'b2^':line 0.5 0.15 0.5 0.3 'bA' plot v1 u2 'r2v':line 0.5 0.7 0.5 0.85 'rA'
C++ code:
void smgl_solve(mglGraph *gr) // solve and evaluate
{
gr->SetRange('z',0,1);
mglData x(20,30), y(20,30), z(20,30), xx,yy,zz;
gr->Fill(x,"(x+2)/3*cos(pi*y)");
gr->Fill(y,"(x+2)/3*sin(pi*y)");
gr->Fill(z,"exp(-6*x^2-2*sin(pi*y)^2)");
gr->SubPlot(2,1,0); gr->Title("Cartesian space"); gr->Rotate(30,-40);
gr->Axis("xyzU"); gr->Box(); gr->Label('x',"x"); gr->Label('y',"y");
gr->SetOrigin(1,1); gr->Grid("xy");
gr->Mesh(x,y,z);
// section along 'x' direction
mglData u = x.Solve(0.5,'x');
mglData v(u.nx); v.Fill(0,1);
xx = x.Evaluate(u,v); yy = y.Evaluate(u,v); zz = z.Evaluate(u,v);
gr->Plot(xx,yy,zz,"k2o");
// 1st section along 'y' direction
mglData u1 = x.Solve(-0.5,'y');
mglData v1(u1.nx); v1.Fill(0,1);
xx = x.Evaluate(v1,u1); yy = y.Evaluate(v1,u1); zz = z.Evaluate(v1,u1);
gr->Plot(xx,yy,zz,"b2^");
// 2nd section along 'y' direction
mglData u2 = x.Solve(-0.5,'y',u1);
xx = x.Evaluate(v1,u2); yy = y.Evaluate(v1,u2); zz = z.Evaluate(v1,u2);
gr->Plot(xx,yy,zz,"r2v");
gr->SubPlot(2,1,1); gr->Title("Accompanied space");
gr->SetRanges(0,1,0,1); gr->SetOrigin(0,0);
gr->Axis(); gr->Box(); gr->Label('x',"i"); gr->Label('y',"j");
gr->Grid(z,"h");
gr->Plot(u,v,"k2o"); gr->Line(mglPoint(0.4,0.5),mglPoint(0.8,0.5),"kA");
gr->Plot(v1,u1,"b2^"); gr->Line(mglPoint(0.5,0.15),mglPoint(0.5,0.3),"bA");
gr->Plot(v1,u2,"r2v"); gr->Line(mglPoint(0.5,0.7),mglPoint(0.5,0.85),"rA");
}
Next: step sample, Previous: solve sample, Up: All samples [Contents][Index]
10.107 Sample ‘stem’
Function stem draw vertical bars. It is most attractive if markers are drawn too.
MGL code:
call 'prepare1d' origin 0 0 0:subplot 2 2 0 '':title 'Stem plot (default)':box:stem y new yc 30 'sin(pi*x)':new xc 30 'cos(pi*x)':new z 30 'x' subplot 2 2 1:title '3d variant':rotate 50 60:box:stem xc yc z 'rx' subplot 2 2 2 '':title '"!" style':box:stem y 'o!rgb'
C++ code:
void smgl_stem(mglGraph *gr)
{
mglData y; mgls_prepare1d(&y); gr->SetOrigin(0,0,0);
mglData yc(30), xc(30), z(30); z.Modify("2*x-1");
yc.Modify("sin(pi*(2*x-1))"); xc.Modify("cos(pi*2*x-pi)");
if(big!=3) { gr->SubPlot(2,2,0,""); gr->Title("Stem plot (default)"); }
gr->Box(); gr->Stem(y);
if(big==3) return;
gr->SubPlot(2,2,1); gr->Title("3d variant"); gr->Rotate(50,60);
gr->Box(); gr->Stem(xc,yc,z,"rx");
gr->SubPlot(2,2,2,""); gr->Title("'!' style"); gr->Box(); gr->Stem(y,"o!rgb");
}
Next: stereo sample, Previous: stem sample, Up: All samples [Contents][Index]
10.108 Sample ‘step’
Function step plot data as stairs. At this stairs can be centered if sizes are differ by 1.
MGL code:
call 'prepare1d' origin 0 0 0:subplot 2 2 0 '':title 'Step plot (default)':box:step y new yc 30 'sin(pi*x)':new xc 30 'cos(pi*x)':new z 30 'x' subplot 2 2 1:title '3d variant':rotate 50 60:box:step xc yc z 'r' subplot 2 2 2 '':title '"!" style':box:step y 's!rgb'
C++ code:
void smgl_step(mglGraph *gr)
{
mglData y; mgls_prepare1d(&y); gr->SetOrigin(0,0,0);
mglData yc(30), xc(30), z(30); z.Modify("2*x-1");
yc.Modify("sin(pi*(2*x-1))"); xc.Modify("cos(pi*2*x-pi)");
if(big!=3) { gr->SubPlot(2,2,0,""); gr->Title("Step plot (default)"); }
gr->Box(); gr->Step(y);
if(big==3) return;
gr->SubPlot(2,2,1); gr->Title("3d variant"); gr->Rotate(50,60);
gr->Box(); gr->Step(xc,yc,z,"r");
gr->SubPlot(2,2,2,""); gr->Title("'!' style"); gr->Box(); gr->Step(y,"s!rgb");
}
Next: stfa sample, Previous: step sample, Up: All samples [Contents][Index]
10.109 Sample ‘stereo’
Example of stereo image of surf.
MGL code:
call 'prepare2d' light on subplot 2 1 0:rotate 50 60+1:box:surf a subplot 2 1 1:rotate 50 60-1:box:surf a
C++ code:
void smgl_stereo(mglGraph *gr)
{
mglData a; mgls_prepare2d(&a);
gr->Light(true);
gr->SubPlot(2,1,0); gr->Rotate(50,60+1);
gr->Box(); gr->Surf(a);
gr->SubPlot(2,1,1); gr->Rotate(50,60-1);
gr->Box(); gr->Surf(a);
}
Next: style sample, Previous: stereo sample, Up: All samples [Contents][Index]
10.110 Sample ‘stfa’
Example of stfa.
MGL code:
new a 2000:new b 2000 fill a 'cos(50*pi*x)*(x<-.5)+cos(100*pi*x)*(x<0)*(x>-.5)+\ cos(200*pi*x)*(x<.5)*(x>0)+cos(400*pi*x)*(x>.5)' subplot 1 2 0 '<_':title 'Initial signal':plot a:axis:xlabel '\i t' subplot 1 2 1 '<_':title 'STFA plot':stfa a b 64:axis:ylabel '\omega' 0:xlabel '\i t'
C++ code:
void smgl_stfa(mglGraph *gr) // STFA sample
{
mglData a(2000), b(2000);
gr->Fill(a,"cos(50*pi*x)*(x<-.5)+cos(100*pi*x)*(x<0)*(x>-.5)+\
cos(200*pi*x)*(x<.5)*(x>0)+cos(400*pi*x)*(x>.5)");
gr->SubPlot(1, 2, 0,"<_"); gr->Title("Initial signal");
gr->Plot(a);
gr->Axis();
gr->Label('x', "\\i t");
gr->SubPlot(1, 2, 1,"<_"); gr->Title("STFA plot");
gr->STFA(a, b, 64);
gr->Axis();
gr->Label('x', "\\i t");
gr->Label('y', "\\omega", 0);
}
Next: surf sample, Previous: stfa sample, Up: All samples [Contents][Index]
10.111 Sample ‘style’
Example of colors and styles for plots.
MGL code:
C++ code:
void smgl_style(mglGraph *gr) // pen styles
{
gr->SubPlot(2,2,0);
double d,x1,x2,x0,y=1.1, y1=1.15;
d=0.3, x0=0.2, x1=0.5, x2=0.6;
gr->Line(mglPoint(x0,y1-0*d),mglPoint(x1,y1-0*d),"k-"); gr->Puts(mglPoint(x2,y-0*d),"Solid '-'",":rL");
gr->Line(mglPoint(x0,y1-1*d),mglPoint(x1,y1-1*d),"k|"); gr->Puts(mglPoint(x2,y-1*d),"Long Dash '|'",":rL");
gr->Line(mglPoint(x0,y1-2*d),mglPoint(x1,y1-2*d),"k;"); gr->Puts(mglPoint(x2,y-2*d),"Dash ';'",":rL");
gr->Line(mglPoint(x0,y1-3*d),mglPoint(x1,y1-3*d),"k="); gr->Puts(mglPoint(x2,y-3*d),"Small dash '='",":rL");
gr->Line(mglPoint(x0,y1-4*d),mglPoint(x1,y1-4*d),"kj"); gr->Puts(mglPoint(x2,y-4*d),"Dash-dot 'j'",":rL");
gr->Line(mglPoint(x0,y1-5*d),mglPoint(x1,y1-5*d),"ki"); gr->Puts(mglPoint(x2,y-5*d),"Small dash-dot 'i'",":rL");
gr->Line(mglPoint(x0,y1-6*d),mglPoint(x1,y1-6*d),"k:"); gr->Puts(mglPoint(x2,y-6*d),"Dots ':'",":rL");
gr->Line(mglPoint(x0,y1-7*d),mglPoint(x1,y1-7*d),"k "); gr->Puts(mglPoint(x2,y-7*d),"None ' '",":rL");
gr->Line(mglPoint(x0,y1-8*d),mglPoint(x1,y1-8*d),"k{df090}"); gr->Puts(mglPoint(x2,y-8*d),"Manual '{df090}'",":rL");
d=0.25; x1=-1; x0=-0.8; y = -0.05;
gr->Mark(mglPoint(x1,5*d),"k."); gr->Puts(mglPoint(x0,y+5*d),"'.'",":rL");
gr->Mark(mglPoint(x1,4*d),"k+"); gr->Puts(mglPoint(x0,y+4*d),"'+'",":rL");
gr->Mark(mglPoint(x1,3*d),"kx"); gr->Puts(mglPoint(x0,y+3*d),"'x'",":rL");
gr->Mark(mglPoint(x1,2*d),"k*"); gr->Puts(mglPoint(x0,y+2*d),"'*'",":rL");
gr->Mark(mglPoint(x1,d),"ks"); gr->Puts(mglPoint(x0,y+d),"'s'",":rL");
gr->Mark(mglPoint(x1,0),"kd"); gr->Puts(mglPoint(x0,y),"'d'",":rL");
gr->Mark(mglPoint(x1,-d,0),"ko"); gr->Puts(mglPoint(x0,y-d),"'o'",":rL");
gr->Mark(mglPoint(x1,-2*d,0),"k^"); gr->Puts(mglPoint(x0,y-2*d),"'\\^'",":rL");
gr->Mark(mglPoint(x1,-3*d,0),"kv"); gr->Puts(mglPoint(x0,y-3*d),"'v'",":rL");
gr->Mark(mglPoint(x1,-4*d,0),"k<"); gr->Puts(mglPoint(x0,y-4*d),"'<'",":rL");
gr->Mark(mglPoint(x1,-5*d,0),"k>"); gr->Puts(mglPoint(x0,y-5*d),"'>'",":rL");
d=0.25; x1=-0.5; x0=-0.3; y = -0.05;
gr->Mark(mglPoint(x1,5*d),"k#."); gr->Puts(mglPoint(x0,y+5*d),"'\\#.'",":rL");
gr->Mark(mglPoint(x1,4*d),"k#+"); gr->Puts(mglPoint(x0,y+4*d),"'\\#+'",":rL");
gr->Mark(mglPoint(x1,3*d),"k#x"); gr->Puts(mglPoint(x0,y+3*d),"'\\#x'",":rL");
gr->Mark(mglPoint(x1,2*d),"k#*"); gr->Puts(mglPoint(x0,y+2*d),"'\\#*'",":rL");
gr->Mark(mglPoint(x1,d),"k#s"); gr->Puts(mglPoint(x0,y+d),"'\\#s'",":rL");
gr->Mark(mglPoint(x1,0),"k#d"); gr->Puts(mglPoint(x0,y),"'\\#d'",":rL");
gr->Mark(mglPoint(x1,-d,0),"k#o"); gr->Puts(mglPoint(x0,y-d),"'\\#o'",":rL");
gr->Mark(mglPoint(x1,-2*d,0),"k#^"); gr->Puts(mglPoint(x0,y-2*d),"'\\#\\^'",":rL");
gr->Mark(mglPoint(x1,-3*d,0),"k#v"); gr->Puts(mglPoint(x0,y-3*d),"'\\#v'",":rL");
gr->Mark(mglPoint(x1,-4*d,0),"k#<"); gr->Puts(mglPoint(x0,y-4*d),"'\\#<'",":rL");
gr->Mark(mglPoint(x1,-5*d,0),"k#>"); gr->Puts(mglPoint(x0,y-5*d),"'\\#>'",":rL");
gr->SubPlot(2,2,1);
double a=0.1,b=0.4,c=0.5;
gr->Line(mglPoint(a,1),mglPoint(b,1),"k-A"); gr->Puts(mglPoint(c,1),"Style 'A' or 'A\\_'",":rL");
gr->Line(mglPoint(a,0.8),mglPoint(b,0.8),"k-V"); gr->Puts(mglPoint(c,0.8),"Style 'V' or 'V\\_'",":rL");
gr->Line(mglPoint(a,0.6),mglPoint(b,0.6),"k-K"); gr->Puts(mglPoint(c,0.6),"Style 'K' or 'K\\_'",":rL");
gr->Line(mglPoint(a,0.4),mglPoint(b,0.4),"k-I"); gr->Puts(mglPoint(c,0.4),"Style 'I' or 'I\\_'",":rL");
gr->Line(mglPoint(a,0.2),mglPoint(b,0.2),"k-D"); gr->Puts(mglPoint(c,0.2),"Style 'D' or 'D\\_'",":rL");
gr->Line(mglPoint(a,0),mglPoint(b,0),"k-S"); gr->Puts(mglPoint(c,0),"Style 'S' or 'S\\_'",":rL");
gr->Line(mglPoint(a,-0.2),mglPoint(b,-0.2),"k-O"); gr->Puts(mglPoint(c,-0.2),"Style 'O' or 'O\\_'",":rL");
gr->Line(mglPoint(a,-0.4),mglPoint(b,-0.4),"k-T"); gr->Puts(mglPoint(c,-0.4),"Style 'T' or 'T\\_'",":rL");
gr->Line(mglPoint(a,-0.6),mglPoint(b,-0.6),"k-X"); gr->Puts(mglPoint(c,-0.6),"Style 'X' or 'X\\_'",":rL");
gr->Line(mglPoint(a,-0.8),mglPoint(b,-0.8),"k-_"); gr->Puts(mglPoint(c,-0.8),"Style '\\_' or none",":rL");
gr->Line(mglPoint(a,-1),mglPoint(b,-1),"k-AS"); gr->Puts(mglPoint(c,-1),"Style 'AS'",":rL");
gr->Line(mglPoint(a,-1.2),mglPoint(b,-1.2),"k-_A"); gr->Puts(mglPoint(c,-1.2),"Style '\\_A'",":rL");
a=-1; b=-0.7; c=-0.6;
gr->Line(mglPoint(a,1),mglPoint(b,1),"kAA"); gr->Puts(mglPoint(c,1),"Style 'AA'",":rL");
gr->Line(mglPoint(a,0.8),mglPoint(b,0.8),"kVV"); gr->Puts(mglPoint(c,0.8),"Style 'VV'",":rL");
gr->Line(mglPoint(a,0.6),mglPoint(b,0.6),"kKK"); gr->Puts(mglPoint(c,0.6),"Style 'KK'",":rL");
gr->Line(mglPoint(a,0.4),mglPoint(b,0.4),"kII"); gr->Puts(mglPoint(c,0.4),"Style 'II'",":rL");
gr->Line(mglPoint(a,0.2),mglPoint(b,0.2),"kDD"); gr->Puts(mglPoint(c,0.2),"Style 'DD'",":rL");
gr->Line(mglPoint(a,0),mglPoint(b,0),"kSS"); gr->Puts(mglPoint(c,0),"Style 'SS'",":rL");
gr->Line(mglPoint(a,-0.2),mglPoint(b,-0.2),"kOO"); gr->Puts(mglPoint(c,-0.2),"Style 'OO'",":rL");
gr->Line(mglPoint(a,-0.4),mglPoint(b,-0.4),"kTT"); gr->Puts(mglPoint(c,-0.4),"Style 'TT'",":rL");
gr->Line(mglPoint(a,-0.6),mglPoint(b,-0.6),"kXX"); gr->Puts(mglPoint(c,-0.6),"Style 'XX'",":rL");
gr->Line(mglPoint(a,-0.8),mglPoint(b,-0.8),"k-__"); gr->Puts(mglPoint(c,-0.8),"Style '\\_\\_'",":rL");
gr->Line(mglPoint(a,-1),mglPoint(b,-1),"k-VA"); gr->Puts(mglPoint(c,-1),"Style 'VA'",":rL");
gr->Line(mglPoint(a,-1.2),mglPoint(b,-1.2),"k-AV"); gr->Puts(mglPoint(c,-1.2),"Style 'AV'",":rL");
gr->SubPlot(2,2,2);
//#LENUQ
gr->FaceZ(mglPoint(-1, -1), 0.4, 0.3, "L#"); gr->Puts(mglPoint(-0.8,-0.9), "L", "w:C", -1.4);
gr->FaceZ(mglPoint(-0.6,-1), 0.4, 0.3, "E#"); gr->Puts(mglPoint(-0.4,-0.9), "E", "w:C", -1.4);
gr->FaceZ(mglPoint(-0.2,-1), 0.4, 0.3, "N#"); gr->Puts(mglPoint(0, -0.9), "N", "w:C", -1.4);
gr->FaceZ(mglPoint(0.2, -1), 0.4, 0.3, "U#"); gr->Puts(mglPoint(0.4,-0.9), "U", "w:C", -1.4);
gr->FaceZ(mglPoint(0.6, -1), 0.4, 0.3, "Q#"); gr->Puts(mglPoint(0.8,-0.9), "Q", "w:C", -1.4);
//#lenuq
gr->FaceZ(mglPoint(-1, -0.7), 0.4, 0.3, "l#"); gr->Puts(mglPoint(-0.8,-0.6), "l", "k:C", -1.4);
gr->FaceZ(mglPoint(-0.6,-0.7), 0.4, 0.3, "e#"); gr->Puts(mglPoint(-0.4,-0.6), "e", "k:C", -1.4);
gr->FaceZ(mglPoint(-0.2,-0.7), 0.4, 0.3, "n#"); gr->Puts(mglPoint(0, -0.6), "n", "k:C", -1.4);
gr->FaceZ(mglPoint(0.2, -0.7), 0.4, 0.3, "u#"); gr->Puts(mglPoint(0.4,-0.6), "u", "k:C", -1.4);
gr->FaceZ(mglPoint(0.6, -0.7), 0.4, 0.3, "q#"); gr->Puts(mglPoint(0.8,-0.6), "q", "k:C", -1.4);
//#CMYkP
gr->FaceZ(mglPoint(-1, -0.4), 0.4, 0.3, "C#"); gr->Puts(mglPoint(-0.8,-0.3), "C", "w:C", -1.4);
gr->FaceZ(mglPoint(-0.6,-0.4), 0.4, 0.3, "M#"); gr->Puts(mglPoint(-0.4,-0.3), "M", "w:C", -1.4);
gr->FaceZ(mglPoint(-0.2,-0.4), 0.4, 0.3, "Y#"); gr->Puts(mglPoint(0, -0.3), "Y", "w:C", -1.4);
gr->FaceZ(mglPoint(0.2, -0.4), 0.4, 0.3, "k#"); gr->Puts(mglPoint(0.4,-0.3), "k", "w:C", -1.4);
gr->FaceZ(mglPoint(0.6, -0.4), 0.4, 0.3, "P#"); gr->Puts(mglPoint(0.8,-0.3), "P", "w:C", -1.4);
//#cmywp
gr->FaceZ(mglPoint(-1, -0.1), 0.4, 0.3, "c#"); gr->Puts(mglPoint(-0.8, 0), "c", "k:C", -1.4);
gr->FaceZ(mglPoint(-0.6,-0.1), 0.4, 0.3, "m#"); gr->Puts(mglPoint(-0.4, 0), "m", "k:C", -1.4);
gr->FaceZ(mglPoint(-0.2,-0.1), 0.4, 0.3, "y#"); gr->Puts(mglPoint(0, 0), "y", "k:C", -1.4);
gr->FaceZ(mglPoint(0.2, -0.1), 0.4, 0.3, "w#"); gr->Puts(mglPoint(0.4, 0), "w", "k:C", -1.4);
gr->FaceZ(mglPoint(0.6, -0.1), 0.4, 0.3, "p#"); gr->Puts(mglPoint(0.8, 0), "p", "k:C", -1.4);
//#BGRHW
gr->FaceZ(mglPoint(-1, 0.2), 0.4, 0.3, "B#"); gr->Puts(mglPoint(-0.8, 0.3), "B", "w:C", -1.4);
gr->FaceZ(mglPoint(-0.6,0.2), 0.4, 0.3, "G#"); gr->Puts(mglPoint(-0.4, 0.3), "G", "w:C", -1.4);
gr->FaceZ(mglPoint(-0.2,0.2), 0.4, 0.3, "R#"); gr->Puts(mglPoint(0, 0.3), "R", "w:C", -1.4);
gr->FaceZ(mglPoint(0.2, 0.2), 0.4, 0.3, "H#"); gr->Puts(mglPoint(0.4, 0.3), "H", "w:C", -1.4);
gr->FaceZ(mglPoint(0.6, 0.2), 0.4, 0.3, "W#"); gr->Puts(mglPoint(0.8, 0.3), "W", "w:C", -1.4);
//#bgrhw
gr->FaceZ(mglPoint(-1, 0.5), 0.4, 0.3, "b#"); gr->Puts(mglPoint(-0.8, 0.6), "b", "k:C", -1.4);
gr->FaceZ(mglPoint(-0.6,0.5), 0.4, 0.3, "g#"); gr->Puts(mglPoint(-0.4, 0.6), "g", "k:C", -1.4);
gr->FaceZ(mglPoint(-0.2,0.5), 0.4, 0.3, "r#"); gr->Puts(mglPoint(0, 0.6), "r", "k:C", -1.4);
gr->FaceZ(mglPoint(0.2, 0.5), 0.4, 0.3, "h#"); gr->Puts(mglPoint(0.4, 0.6), "h", "k:C", -1.4);
gr->FaceZ(mglPoint(0.6, 0.5), 0.4, 0.3, "w#"); gr->Puts(mglPoint(0.8, 0.6), "w", "k:C", -1.4);
//#brighted
gr->FaceZ(mglPoint(-1, 0.8), 0.4, 0.3, "{r1}#"); gr->Puts(mglPoint(-0.8, 0.9), "\\{r1\\}", "w:C", -1.4);
gr->FaceZ(mglPoint(-0.6,0.8), 0.4, 0.3, "{r3}#"); gr->Puts(mglPoint(-0.4, 0.9), "\\{r3\\}", "w:C", -1.4);
gr->FaceZ(mglPoint(-0.2,0.8), 0.4, 0.3, "{r5}#"); gr->Puts(mglPoint(0, 0.9), "\\{r5\\}", "k:C", -1.4);
gr->FaceZ(mglPoint(0.2, 0.8), 0.4, 0.3, "{r7}#"); gr->Puts(mglPoint(0.4, 0.9), "\\{r7\\}", "k:C", -1.4);
gr->FaceZ(mglPoint(0.6, 0.8), 0.4, 0.3, "{r9}#"); gr->Puts(mglPoint(0.8, 0.9), "\\{r9\\}", "k:C", -1.4);
// HEX
gr->FaceZ(mglPoint(-1, -1.3), 1, 0.3, "{xff9966}#"); gr->Puts(mglPoint(-0.5,-1.2), "\\{xff9966\\}", "k:C", -1.4);
gr->FaceZ(mglPoint(0, -1.3), 1, 0.3, "{x83CAFF}#"); gr->Puts(mglPoint( 0.5,-1.2), "\\{x83CAFF\\}", "k:C", -1.4);
gr->SubPlot(2,2,3);
char stl[3]="r1", txt[4]="'1'";
for(int i=0;i<10;i++)
{
txt[1]=stl[1]='0'+i;
gr->Line(mglPoint(-1,0.2*i-1),mglPoint(1,0.2*i-1),stl);
gr->Puts(mglPoint(1.05,0.2*i-1),txt,":L");
}
}
Next: surf3 sample, Previous: style sample, Up: All samples [Contents][Index]
10.112 Sample ‘surf’
Function surf is most standard way to visualize 2D data array. Surf use color scheme for coloring (see Color scheme). You can use ‘#’ style for drawing black meshes on the surface.
MGL code:
call 'prepare2d' subplot 2 2 0:title 'Surf plot (default)':rotate 50 60:light on:box:surf a subplot 2 2 1:title '"\#" style; meshnum 10':rotate 50 60:box:surf a '#'; meshnum 10 subplot 2 2 2:title '"." style':rotate 50 60:box:surf a '.' new x 50 40 '0.8*sin(pi*x)*sin(pi*(y+1)/2)' new y 50 40 '0.8*cos(pi*x)*sin(pi*(y+1)/2)' new z 50 40 '0.8*cos(pi*(y+1)/2)' subplot 2 2 3:title 'parametric form':rotate 50 60:box:surf x y z 'BbwrR'
C++ code:
void smgl_surf3(mglGraph *gr)
{
mglData c; mgls_prepare3d(&c);
if(big!=3) { gr->SubPlot(2,2,0); gr->Title("Surf3 plot (default)"); }
gr->Rotate(50,60); gr->Light(true); gr->Alpha(true);
gr->Box(); gr->Surf3(c);
if(big==3) return;
gr->SubPlot(2,2,1); gr->Title("'\\#' style");
gr->Rotate(50,60); gr->Box(); gr->Surf3(c,"#");
gr->SubPlot(2,2,2); gr->Title("'.' style");
gr->Rotate(50,60); gr->Box(); gr->Surf3(c,".");
}
Next: surf3a sample, Previous: surf sample, Up: All samples [Contents][Index]
10.113 Sample ‘surf3’
Function surf3 is one of most suitable (for my opinion) functions to visualize 3D data. It draw the isosurface(s) – surface(s) of constant amplitude (3D analogue of contour lines). You can draw wired isosurfaces if specify ‘#’ style.
MGL code:
call 'prepare3d' light on:alpha on subplot 2 2 0:title 'Surf3 plot (default)' rotate 50 60:box:surf3 c subplot 2 2 1:title '"\#" style' rotate 50 60:box:surf3 c '#' subplot 2 2 2:title '"." style' rotate 50 60:box:surf3 c '.'
C++ code:
void smgl_surf3(mglGraph *gr)
{
mglData c; mgls_prepare3d(&c);
if(big!=3) { gr->SubPlot(2,2,0); gr->Title("Surf3 plot (default)"); }
gr->Rotate(50,60); gr->Light(true); gr->Alpha(true);
gr->Box(); gr->Surf3(c);
if(big==3) return;
gr->SubPlot(2,2,1); gr->Title("'\\#' style");
gr->Rotate(50,60); gr->Box(); gr->Surf3(c,"#");
gr->SubPlot(2,2,2); gr->Title("'.' style");
gr->Rotate(50,60); gr->Box(); gr->Surf3(c,".");
}
Next: surf3c sample, Previous: surf3 sample, Up: All samples [Contents][Index]
10.114 Sample ‘surf3a’
Function surf3c is similar to surf3 but its transparency is determined by another data.
MGL code:
call 'prepare3d' title 'Surf3A plot':rotate 50 60:light on:alpha on:box:surf3a c d
C++ code:
void smgl_surf3a(mglGraph *gr)
{
mglData c,d; mgls_prepare3d(&c,&d);
if(big!=3) gr->Title("Surf3A plot");
gr->Rotate(50,60); gr->Light(true); gr->Alpha(true);
gr->Box(); gr->Surf3A(c,d);
}
Next: surf3ca sample, Previous: surf3a sample, Up: All samples [Contents][Index]
10.115 Sample ‘surf3c’
Function surf3c is similar to surf3 but its coloring is determined by another data.
MGL code:
call 'prepare3d' title 'Surf3C plot':rotate 50 60:light on:alpha on:box:surf3c c d
C++ code:
void smgl_surf3c(mglGraph *gr)
{
mglData c,d; mgls_prepare3d(&c,&d);
if(big!=3) gr->Title("Surf3C plot");
gr->Rotate(50,60); gr->Light(true); gr->Alpha(true);
gr->Box(); gr->Surf3C(c,d);
}
Next: surfa sample, Previous: surf3c sample, Up: All samples [Contents][Index]
10.116 Sample ‘surf3ca’
Function surf3c is similar to surf3 but its coloring and transparency is determined by another data arrays.
MGL code:
call 'prepare3d' title 'Surf3CA plot':rotate 50 60:light on:alpha on:box:surf3ca c d c
C++ code:
void smgl_surf3ca(mglGraph *gr)
{
mglData c,d; mgls_prepare3d(&c,&d);
if(big!=3) gr->Title("Surf3CA plot");
gr->Rotate(50,60); gr->Light(true); gr->Alpha(true);
gr->Box(); gr->Surf3CA(c,d,c);
}
Next: surfc sample, Previous: surf3ca sample, Up: All samples [Contents][Index]
10.117 Sample ‘surfa’
Function surfa is similar to surf but its transparency is determined by another data.
MGL code:
call 'prepare2d' title 'SurfA plot':rotate 50 60:light on:alpha on:box:surfa a b
C++ code:
void smgl_surfa(mglGraph *gr)
{
mglData a,b; mgls_prepare2d(&a,&b);
if(big!=3) gr->Title("SurfA plot");
gr->Rotate(50,60); gr->Alpha(true); gr->Light(true); gr->Box();
gr->SurfA(a,b);
}
Next: surfca sample, Previous: surfa sample, Up: All samples [Contents][Index]
10.118 Sample ‘surfc’
Function surfc is similar to surf but its coloring is determined by another data.
MGL code:
call 'prepare2d' title 'SurfC plot':rotate 50 60:light on:box:surfc a b
C++ code:
void smgl_surfc(mglGraph *gr)
{
mglData a,b; mgls_prepare2d(&a,&b);
if(big!=3) gr->Title("SurfC plot");
gr->Rotate(50,60); gr->Light(true); gr->Box(); gr->SurfC(a,b);
}
Next: table sample, Previous: surfc sample, Up: All samples [Contents][Index]
10.119 Sample ‘surfca’
Function surfca is similar to surf but its coloring and transparency is determined by another data arrays.
MGL code:
call 'prepare2d' title 'SurfCA plot':rotate 50 60:light on:alpha on:box:surfca a b a
C++ code:
void smgl_surfca(mglGraph *gr)
{
mglData a,b; mgls_prepare2d(&a,&b);
if(big!=3) gr->Title("SurfCA plot");
gr->Rotate(50,60); gr->Alpha(true); gr->Light(true); gr->Box();
gr->SurfCA(a,b,a);
}
Next: tape sample, Previous: surfca sample, Up: All samples [Contents][Index]
10.120 Sample ‘table’
Function table draw table with data values.
MGL code:
new ys 10 3 '0.8*sin(pi*(x+y/4+1.25))+0.2*rnd'
subplot 2 2 0:title 'Table sample':box
table ys 'y_1\n{}y_2\n{}y_3'
subplot 2 2 1:title 'no borders, colored'
table ys 'y_1\n{}y_2\n{}y_3' 'r|'
subplot 2 2 2:title 'no font decrease'
table ys 'y_1\n{}y_2\n{}y_3' '#'
subplot 2 2 3:title 'manual width and position':box
table 0.5 0.95 ys 'y_1\n{}y_2\n{}y_3' '#';value 0.7
C++ code:
void smgl_table(mglGraph *gr)
{
mglData ys(10,3); ys.Modify("0.8*sin(pi*(2*x+y/2))+0.2*rnd");
if(big!=3) { gr->SubPlot(2,2,0); gr->Title("Table plot"); }
gr->Table(ys,"y_1\ny_2\ny_3"); gr->Box();
if(big==3) return;
gr->SubPlot(2,2,1); gr->Title("no borders, colored");
gr->Table(ys,"y_1\ny_2\ny_3","r|");
gr->SubPlot(2,2,2); gr->Title("no font decrease");
gr->Table(ys,"y_1\ny_2\ny_3","#");
gr->SubPlot(2,2,3); gr->Title("manual width, position");
gr->Table(0.5, 0.95, ys,"y_1\ny_2\ny_3","#", "value 0.7"); gr->Box();
}
Next: tens sample, Previous: table sample, Up: All samples [Contents][Index]
10.121 Sample ‘tape’
Function tape draw tapes which rotate around the curve as transverse orts of accompanied coordinates.
MGL code:
call 'prepare1d' new yc 50 'sin(pi*x)':new xc 50 'cos(pi*x)':new z 50 'x' subplot 2 2 0 '':title 'Tape plot (default)':box:tape y:plot y 'k' subplot 2 2 1:title '3d variant, 2 colors':rotate 50 60:light on box:plot xc yc z 'k':tape xc yc z 'rg' subplot 2 2 2:title '3d variant, x only':rotate 50 60 box:plot xc yc z 'k':tape xc yc z 'xr':tape xc yc z 'xr#' subplot 2 2 3:title '3d variant, z only':rotate 50 60 box:plot xc yc z 'k':tape xc yc z 'zg':tape xc yc z 'zg#'
C++ code:
void smgl_tape(mglGraph *gr)
{
mglData y; mgls_prepare1d(&y);
mglData xc(50), yc(50), z(50);
yc.Modify("sin(pi*(2*x-1))");
xc.Modify("cos(pi*2*x-pi)"); z.Fill(-1,1);
if(big!=3) { gr->SubPlot(2,2,0,""); gr->Title("Tape plot (default)"); }
gr->Box(); gr->Tape(y); gr->Plot(y,"k");
if(big==3) return;
gr->SubPlot(2,2,1); gr->Title("3d variant, 2 colors"); gr->Rotate(50,60); gr->Light(true);
gr->Box(); gr->Plot(xc,yc,z,"k"); gr->Tape(xc,yc,z,"rg");
gr->SubPlot(2,2,2); gr->Title("3d variant, x only"); gr->Rotate(50,60);
gr->Box(); gr->Plot(xc,yc,z,"k"); gr->Tape(xc,yc,z,"xr"); gr->Tape(xc,yc,z,"xr#");
gr->SubPlot(2,2,3); gr->Title("3d variant, z only"); gr->Rotate(50,60);
gr->Box(); gr->Plot(xc,yc,z,"k"); gr->Tape(xc,yc,z,"zg"); gr->Tape(xc,yc,z,"zg#");
}
Next: ternary sample, Previous: tape sample, Up: All samples [Contents][Index]
10.122 Sample ‘tens’
Function tens is variant of plot with smooth coloring along the curves. At this, color is determined as for surfaces (see Color scheme).
MGL code:
call 'prepare1d' subplot 2 2 0 '':title 'Tens plot (default)':box:tens y(:,0) y(:,1) subplot 2 2 2 '':title '" " style':box:tens y(:,0) y(:,1) 'o ' new yc 30 'sin(pi*x)':new xc 30 'cos(pi*x)':new z 30 'x' subplot 2 2 1:title '3d variant':rotate 50 60:box:tens xc yc z z 's'
C++ code:
void smgl_tens(mglGraph *gr)
{
mglData y; mgls_prepare1d(&y); gr->SetOrigin(0,0,0);
if(big!=3) { gr->SubPlot(2,2,0,""); gr->Title("Tens plot (default)"); }
gr->Box(); gr->Tens(y.SubData(-1,0), y.SubData(-1,1));
if(big==3) return;
gr->SubPlot(2,2,2,""); gr->Title("' ' style"); gr->Box(); gr->Tens(y.SubData(-1,0), y.SubData(-1,1),"o ");
gr->SubPlot(2,2,1); gr->Title("3d variant"); gr->Rotate(50,60); gr->Box();
mglData yc(30), xc(30), z(30); z.Modify("2*x-1");
yc.Modify("sin(pi*(2*x-1))"); xc.Modify("cos(pi*2*x-pi)");
gr->Tens(xc,yc,z,z,"s");
}
Next: text sample, Previous: tens sample, Up: All samples [Contents][Index]
10.123 Sample ‘ternary’
Example of ternary coordinates.
MGL code:
ranges 0 1 0 1 0 1 new x 50 '0.25*(1+cos(2*pi*x))' new y 50 '0.25*(1+sin(2*pi*x))' new z 50 'x' new a 20 30 '30*x*y*(1-x-y)^2*(x+y<1)' new rx 10 'rnd':new ry 10:fill ry '(1-v)*rnd' rx light on subplot 2 2 0:title 'Ordinary axis 3D':rotate 50 60 box:axis:grid plot x y z 'r2':surf a '#' xlabel 'B':ylabel 'C':zlabel 'Z' subplot 2 2 1:title 'Ternary axis (x+y+t=1)':ternary 1 box:axis:grid 'xyz' 'B;' plot x y 'r2':plot rx ry 'q^ ':cont a:line 0.5 0 0 0.75 'g2' xlabel 'B':ylabel 'C':tlabel 'A' subplot 2 2 2:title 'Quaternary axis 3D':rotate 50 60:ternary 2 box:axis:grid 'xyz' 'B;' plot x y z 'r2':surf a '#' xlabel 'B':ylabel 'C':tlabel 'A':zlabel 'D' subplot 2 2 3:title 'Ternary axis 3D':rotate 50 60:ternary 1 box:axis:grid 'xyz' 'B;' plot x y z 'r2':surf a '#' xlabel 'B':ylabel 'C':tlabel 'A':zlabel 'Z'
C++ code:
void smgl_ternary(mglGraph *gr) // flag #
{
gr->SetRanges(0,1,0,1,0,1);
mglData x(50),y(50),z(50),rx(10),ry(10), a(20,30);
a.Modify("30*x*y*(1-x-y)^2*(x+y<1)");
x.Modify("0.25*(1+cos(2*pi*x))");
y.Modify("0.25*(1+sin(2*pi*x))");
rx.Modify("rnd"); ry.Modify("(1-v)*rnd",rx);
z.Modify("x");
gr->SubPlot(2,2,0); gr->Title("Ordinary axis 3D");
gr->Rotate(50,60); gr->Light(true);
gr->Plot(x,y,z,"r2"); gr->Surf(a,"BbcyrR#");
gr->Axis(); gr->Grid(); gr->Box();
gr->Label('x',"B",1); gr->Label('y',"C",1); gr->Label('z',"Z",1);
gr->SubPlot(2,2,1); gr->Title("Ternary axis (x+y+t=1)");
gr->Ternary(1);
gr->Plot(x,y,"r2"); gr->Plot(rx,ry,"q^ "); gr->Cont(a);
gr->Line(mglPoint(0.5,0), mglPoint(0,0.75), "g2");
gr->Axis(); gr->Grid("xyz","B;");
gr->Label('x',"B"); gr->Label('y',"C"); gr->Label('t',"A");
gr->SubPlot(2,2,2); gr->Title("Quaternary axis 3D");
gr->Rotate(50,60); gr->Light(true);
gr->Ternary(2);
gr->Plot(x,y,z,"r2"); gr->Surf(a,"BbcyrR#");
gr->Axis(); gr->Grid(); gr->Box();
gr->Label('t',"A",1); gr->Label('x',"B",1);
gr->Label('y',"C",1); gr->Label('z',"D",1);
gr->SubPlot(2,2,3); gr->Title("Ternary axis 3D");
gr->Rotate(50,60); gr->Light(true);
gr->Ternary(1);
gr->Plot(x,y,z,"r2"); gr->Surf(a,"BbcyrR#");
gr->Axis(); gr->Grid(); gr->Box();
gr->Label('t',"A",1); gr->Label('x',"B",1);
gr->Label('y',"C",1); gr->Label('z',"Z",1);
}
Next: text2 sample, Previous: ternary sample, Up: All samples [Contents][Index]
10.124 Sample ‘text’
Example of text possibilities.
MGL code:
call 'prepare1d'
subplot 2 2 0 ''
text 0 1 'Text can be in ASCII and in Unicode'
text 0 0.6 'It can be \wire{wire}, \big{big} or #r{colored}'
text 0 0.2 'One can change style in string: \b{bold}, \i{italic, \b{both}}'
text 0 -0.2 'Easy to \a{overline} or \u{underline}'
text 0 -0.6 'Easy to change indexes ^{up} _{down} @{center}'
text 0 -1 'It parse TeX: \int \alpha \cdot \
\sqrt3{sin(\pi x)^2 + \gamma_{i_k}} dx'
subplot 2 2 1 ''
text 0 0.5 '\sqrt{\frac{\alpha^{\gamma^2}+\overset 1{\big\infty}}{\sqrt3{2+b}}}' '@' -2
text 0 -0.1 'More text position: \frac{a}{b}, \dfrac{a}{b}, [\stack{a}{bbb}], [\stackl{a}{bbb}], [\stackr{a}{bbb}], \sup{a}{sup}, \sub{a}{sub}'text 0 -0.5 'Text can be printed\n{}on several lines'
text 0 -0.9 'or with color gradient' 'BbcyrR'
subplot 2 2 2 '':box:plot y(:,0)
text y 'This is very very long string drawn along a curve' 'k'
text y 'Another string drawn above a curve' 'Tr'
subplot 2 2 3 '':line -1 -1 1 -1 'rA':text 0 -1 1 -1 'Horizontal'
line -1 -1 1 1 'rA':text 0 0 1 1 'At angle' '@'
line -1 -1 -1 1 'rA':text -1 0 -1 1 'Vertical'
C++ code:
void smgl_text(mglGraph *gr) // text drawing
{
if(big!=3) gr->SubPlot(2,2,0,"");
gr->Putsw(mglPoint(0,1),L"Text can be in ASCII and in Unicode");
gr->Puts(mglPoint(0,0.6),"It can be \\wire{wire}, \\big{big} or #r{colored}");
gr->Puts(mglPoint(0,0.2),"One can change style in string: "
"\\b{bold}, \\i{italic, \\b{both}}");
gr->Puts(mglPoint(0,-0.2),"Easy to \\a{overline} or "
"\\u{underline}");
gr->Puts(mglPoint(0,-0.6),"Easy to change indexes ^{up} _{down} @{center}");
gr->Puts(mglPoint(0,-1),"It parse TeX: \\int \\alpha \\cdot "
"\\sqrt3{sin(\\pi x)^2 + \\gamma_{i_k}} dx");
if(big==3) return;
gr->SubPlot(2,2,1,"");
gr->Puts(mglPoint(0,0.5), "\\sqrt{\\frac{\\alpha^{\\gamma^2}+\\overset 1{\\big\\infty}}{\\sqrt3{2+b}}}", "@", -2);
gr->Puts(mglPoint(0,-0.1),"More text position: \\frac{a}{b}, \\dfrac{a}{b}, [\\stack{a}{bbb}], [\\stackl{a}{bbb}], [\\stackr{a}{bbb}], \\sup{a}{sup}, \\sub{a}{sub}");
gr->Puts(mglPoint(0,-0.5),"Text can be printed\non several lines");
gr->Puts(mglPoint(0,-0.9),"or with col\bor gradient","BbcyrR");
gr->SubPlot(2,2,2,"");
mglData y; mgls_prepare1d(&y);
gr->Box(); gr->Plot(y.SubData(-1,0));
gr->Text(y,"This is very very long string drawn along a curve","k");
gr->Text(y,"Another string drawn under a curve","Tr");
gr->SubPlot(2,2,3,"");
gr->Line(mglPoint(-1,-1),mglPoint(1,-1),"rA"); gr->Puts(mglPoint(0,-1),mglPoint(1,-1),"Horizontal");
gr->Line(mglPoint(-1,-1),mglPoint(1,1),"rA"); gr->Puts(mglPoint(0,0),mglPoint(1,1),"At angle","@");
gr->Line(mglPoint(-1,-1),mglPoint(-1,1),"rA"); gr->Puts(mglPoint(-1,0),mglPoint(-1,1),"Vertical");
}
Next: textmark sample, Previous: text sample, Up: All samples [Contents][Index]
10.125 Sample ‘text2’
Example of text along curve.
MGL code:
call 'prepare1d' subplot 1 3 0 '':box:plot y(:,0) text y 'This is very very long string drawn along a curve' 'k' text y 'Another string drawn under a curve' 'Tr' subplot 1 3 1 '':box:plot y(:,0) text y 'This is very very long string drawn along a curve' 'k:C' text y 'Another string drawn under a curve' 'Tr:C' subplot 1 3 2 '':box:plot y(:,0) text y 'This is very very long string drawn along a curve' 'k:R' text y 'Another string drawn under a curve' 'Tr:R'
C++ code:
void smgl_text2(mglGraph *gr) // text drawing
{
mglData y; mgls_prepare1d(&y);
if(big!=3) gr->SubPlot(1,3,0,"");
gr->Box(); gr->Plot(y.SubData(-1,0));
gr->Text(y,"This is very very long string drawn along a curve","k");
gr->Text(y,"Another string drawn under a curve","Tr");
if(big==3) return;
gr->SubPlot(1,3,1,"");
gr->Box(); gr->Plot(y.SubData(-1,0));
gr->Text(y,"This is very very long string drawn along a curve","k:C");
gr->Text(y,"Another string drawn under a curve","Tr:C");
gr->SubPlot(1,3,2,"");
gr->Box(); gr->Plot(y.SubData(-1,0));
gr->Text(y,"This is very very long string drawn along a curve","k:R");
gr->Text(y,"Another string drawn under a curve","Tr:R");
}
Next: ticks sample, Previous: text2 sample, Up: All samples [Contents][Index]
10.126 Sample ‘textmark’
Function textmark is similar to mark but draw text instead of markers.
MGL code:
call 'prepare1d' subplot 1 1 0 '':title 'TextMark plot (default)':box:textmark y y1 '\gamma' 'r'
C++ code:
void smgl_textmark(mglGraph *gr)
{
mglData y,y1; mgls_prepare1d(&y,&y1);
if(big!=3) { gr->SubPlot(1,1,0,""); gr->Title("TextMark plot (default)"); }
gr->Box(); gr->TextMark(y,y1,"\\gamma","r");
}
Next: tile sample, Previous: textmark sample, Up: All samples [Contents][Index]
10.127 Sample ‘ticks’
Example of axis ticks.
MGL code:
subplot 3 3 0:title 'Usual axis with ":" style' axis ':' subplot 3 3 1:title 'Too big/small range' ranges -1000 1000 0 0.001:axis subplot 3 3 2:title 'LaTeX-like labels' axis 'F!' subplot 3 3 3:title 'Too narrow range' ranges 100 100.1 10 10.01:axis subplot 3 3 4:title 'No tuning, manual "+"' axis '+!' # for version <2.3 you can use #tuneticks off:axis subplot 3 3 5:title 'Template for ticks' xtick 'xxx:%g':ytick 'y:%g' axis xtick '':ytick '' # switch it off for other plots subplot 3 3 6:title 'No tuning, higher precision' axis '!4' subplot 3 3 7:title 'Manual ticks' ranges -pi pi 0 2 xtick pi 3 '\pi' xtick 0.886 'x^*' on # note this will disable subticks drawing # or you can use #xtick -pi '\pi' -pi/2 '-\pi/2' 0 '0' 0.886 'x^*' pi/2 '\pi/2' pi 'pi' list v 0 0.5 1 2:ytick v '0 0.5 1 2' axis:grid:fplot '2*cos(x^2)^2' 'r2' subplot 3 3 8:title 'Time ticks' xrange 0 3e5:ticktime 'x':axis
C++ code:
void smgl_ticks(mglGraph *gr)
{
gr->SubPlot(3,3,0); gr->Title("Usual axis with ':' style"); gr->Axis(":");
gr->SubPlot(3,3,1); gr->Title("Too big/small range");
gr->SetRanges(-1000,1000,0,0.001); gr->Axis();
gr->SubPlot(3,3,2); gr->Title("LaTeX-like labels");
gr->Axis("F!");
gr->SubPlot(3,3,3); gr->Title("Too narrow range");
gr->SetRanges(100,100.1,10,10.01); gr->Axis();
gr->SubPlot(3,3,4); gr->Title("No tuning, manual '+'");
// for version<2.3 you need first call gr->SetTuneTicks(0);
gr->Axis("+!");
gr->SubPlot(3,3,5); gr->Title("Template for ticks");
gr->SetTickTempl('x',"xxx:%g"); gr->SetTickTempl('y',"y:%g");
gr->Axis();
// now switch it off for other plots
gr->SetTickTempl('x',""); gr->SetTickTempl('y',"");
gr->SubPlot(3,3,6); gr->Title("No tuning, higher precision");
gr->Axis("!4");
gr->SubPlot(3,3,7); gr->Title("Manual ticks"); gr->SetRanges(-M_PI,M_PI, 0, 2);
gr->SetTicks('x',M_PI,0,0,"\\pi"); gr->AddTick('x',0.886,"x^*");
// alternatively you can use following lines
double val[]={0, 0.5, 1, 2};
gr->SetTicksVal('y', mglData(4,val), "0\n0.5\n1\n2");
gr->Axis(); gr->Grid(); gr->FPlot("2*cos(x^2)^2", "r2");
gr->SubPlot(3,3,8); gr->Title("Time ticks"); gr->SetRange('x',0,3e5);
gr->SetTicksTime('x',0); gr->Axis();
}
Next: tiles sample, Previous: ticks sample, Up: All samples [Contents][Index]
10.128 Sample ‘tile’
Function tile draw surface by tiles.
MGL code:
call 'prepare2d' title 'Tile plot':rotate 50 60:box:tile a
C++ code:
void smgl_tile(mglGraph *gr)
{
mglData a; mgls_prepare2d(&a);
if(big!=3) gr->Title("Tile plot");
gr->Rotate(40,60); gr->Box(); gr->Tile(a);
}
Next: torus sample, Previous: tile sample, Up: All samples [Contents][Index]
10.129 Sample ‘tiles’
Function tiles is similar to tile but tile sizes is determined by another data. This allows one to simulate transparency of the plot.
MGL code:
call 'prepare2d' subplot 1 1 0 '':title 'Tiles plot':box:tiles a b
C++ code:
void smgl_tiles(mglGraph *gr)
{
mglData a,b; mgls_prepare2d(&a,&b);
if(big!=3) {gr->SubPlot(1,1,0,""); gr->Title("TileS plot");}
gr->Box(); gr->TileS(a,b);
}
Next: traj sample, Previous: tiles sample, Up: All samples [Contents][Index]
10.130 Sample ‘torus’
Function torus draw surface of the curve rotation.
MGL code:
call 'prepare1d' subplot 2 2 0:title 'Torus plot (default)':light on:rotate 50 60:box:torus y1 y2 subplot 2 2 1:title '"x" style':light on:rotate 50 60:box:torus y1 y2 'x' subplot 2 2 2:title '"z" style':light on:rotate 50 60:box:torus y1 y2 'z' subplot 2 2 3:title '"\#" style':light on:rotate 50 60:box:torus y1 y2 '#'
C++ code:
void smgl_torus(mglGraph *gr)
{
mglData y1,y2; mgls_prepare1d(0,&y1,&y2);
if(big!=3) { gr->SubPlot(2,2,0); gr->Title("Torus plot (default)"); }
gr->Light(true); gr->Rotate(50,60); gr->Box(); gr->Torus(y1,y2);
if(big==3) return;
gr->SubPlot(2,2,1); gr->Title("'x' style"); gr->Rotate(50,60); gr->Box(); gr->Torus(y1,y2,"x");
gr->SubPlot(2,2,2); gr->Title("'z' style"); gr->Rotate(50,60); gr->Box(); gr->Torus(y1,y2,"z");
gr->SubPlot(2,2,3); gr->Title("'\\#' style"); gr->Rotate(50,60); gr->Box(); gr->Torus(y1,y2,"#");
}
Next: triangulation sample, Previous: torus sample, Up: All samples [Contents][Index]
10.131 Sample ‘traj’
Function traj is 1D analogue of vect. It draw vectors from specified points.
MGL code:
call 'prepare1d' subplot 1 1 0 '':title 'Traj plot':box:plot x1 y:traj x1 y y1 y2
C++ code:
void smgl_traj(mglGraph *gr)
{
mglData x,y,y1,y2; mgls_prepare1d(&y,&y1,&y2,&x);
if(big!=3) {gr->SubPlot(1,1,0,""); gr->Title("Traj plot");}
gr->Box(); gr->Plot(x,y); gr->Traj(x,y,y1,y2);
}
Next: triplot sample, Previous: traj sample, Up: All samples [Contents][Index]
10.132 Sample ‘triangulation’
Example of use triangulate for arbitrary placed points.
MGL code:
new x 100 '2*rnd-1':new y 100 '2*rnd-1':copy z x^2-y^2 new g 30 30:triangulate d x y title 'Triangulation' rotate 50 60:box:light on triplot d x y z:triplot d x y z '#k' datagrid g x y z:mesh g 'm'
C++ code:
void smgl_triangulation(mglGraph *gr) // surface triangulation
{
mglData x(100), y(100), z(100);
gr->Fill(x,"2*rnd-1"); gr->Fill(y,"2*rnd-1"); gr->Fill(z,"v^2-w^2",x,y);
mglData d = mglTriangulation(x,y), g(30,30);
if(big!=3) gr->Title("Triangulation");
gr->Rotate(40,60); gr->Box(); gr->Light(true);
gr->TriPlot(d,x,y,z); gr->TriPlot(d,x,y,z,"#k");
gr->DataGrid(g,x,y,z); gr->Mesh(g,"m");
}
Next: tube sample, Previous: triangulation sample, Up: All samples [Contents][Index]
10.133 Sample ‘triplot’
Functions triplot and quadplot draw set of triangles (or quadrangles, correspondingly) for irregular data arrays. Note, that you have to provide not only vertexes, but also the indexes of triangles or quadrangles. I.e. perform triangulation by some other library. See also triangulate.
MGL code:
list q 0 1 2 3 | 4 5 6 7 | 0 2 4 6 | 1 3 5 7 | 0 4 1 5 | 2 6 3 7 list xq -1 1 -1 1 -1 1 -1 1 list yq -1 -1 1 1 -1 -1 1 1 list zq -1 -1 -1 -1 1 1 1 1 light on subplot 2 2 0:title 'QuadPlot sample':rotate 50 60 quadplot q xq yq zq 'yr' quadplot q xq yq zq '#k' subplot 2 2 2:title 'QuadPlot coloring':rotate 50 60 quadplot q xq yq zq yq 'yr' quadplot q xq yq zq '#k' list t 0 1 2 | 0 1 3 | 0 2 3 | 1 2 3 list xt -1 1 0 0 list yt -1 -1 1 0 list zt -1 -1 -1 1 subplot 2 2 1:title 'TriPlot sample':rotate 50 60 triplot t xt yt zt 'b' triplot t xt yt zt '#k' subplot 2 2 3:title 'TriPlot coloring':rotate 50 60 triplot t xt yt zt yt 'cb' triplot t xt yt zt '#k' tricont t xt yt zt 'B'
C++ code:
void smgl_triplot(mglGraph *gr)
{
double q[] = {0,1,2,3, 4,5,6,7, 0,2,4,6, 1,3,5,7, 0,4,1,5, 2,6,3,7};
double xc[] = {-1,1,-1,1,-1,1,-1,1}, yc[] = {-1,-1,1,1,-1,-1,1,1}, zc[] = {-1,-1,-1,-1,1,1,1,1};
mglData qq(6,4,q), xx(8,xc), yy(8,yc), zz(8,zc);
gr->Light(true); //gr->Alpha(true);
gr->SubPlot(2,2,0); gr->Title("QuadPlot sample"); gr->Rotate(50,60);
gr->QuadPlot(qq,xx,yy,zz,"yr");
gr->QuadPlot(qq,xx,yy,zz,"k#");
gr->SubPlot(2,2,2); gr->Title("QuadPlot coloring"); gr->Rotate(50,60);
gr->QuadPlot(qq,xx,yy,zz,yy,"yr");
gr->QuadPlot(qq,xx,yy,zz,"k#");
double t[] = {0,1,2, 0,1,3, 0,2,3, 1,2,3};
double xt[] = {-1,1,0,0}, yt[] = {-1,-1,1,0}, zt[] = {-1,-1,-1,1};
mglData tt(4,3,t), uu(4,xt), vv(4,yt), ww(4,zt);
gr->SubPlot(2,2,1); gr->Title("TriPlot sample"); gr->Rotate(50,60);
gr->TriPlot(tt,uu,vv,ww,"b");
gr->TriPlot(tt,uu,vv,ww,"k#");
gr->SubPlot(2,2,3); gr->Title("TriPlot coloring"); gr->Rotate(50,60);
gr->TriPlot(tt,uu,vv,ww,vv,"cb");
gr->TriPlot(tt,uu,vv,ww,"k#");
gr->TriCont(tt,uu,vv,ww,"B");
}
Next: type0 sample, Previous: triplot sample, Up: All samples [Contents][Index]
10.134 Sample ‘tube’
Function tube draw tube with variable radius.
MGL code:
call 'prepare1d' light on new yc 50 'sin(pi*x)':new xc 50 'cos(pi*x)':new z 50 'x':divto y1 20 subplot 2 2 0 '':title 'Tube plot (default)':box:tube y 0.05 subplot 2 2 1 '':title 'variable radius':box:tube y y1 subplot 2 2 2 '':title '"\#" style':box:tube y 0.05 '#' subplot 2 2 3:title '3d variant':rotate 50 60:box:tube xc yc z y2 'r'
C++ code:
void smgl_tube(mglGraph *gr)
{
mglData y,y1,y2; mgls_prepare1d(&y,&y1,&y2); y1/=20;
if(big!=3) { gr->SubPlot(2,2,0,""); gr->Title("Tube plot (default)"); }
gr->Light(true); gr->Box(); gr->Tube(y,0.05);
if(big==3) return;
gr->SubPlot(2,2,1,""); gr->Title("variable radius"); gr->Box(); gr->Tube(y,y1);
gr->SubPlot(2,2,2,""); gr->Title("'\\#' style"); gr->Box(); gr->Tube(y,0.05,"#");
mglData yc(50), xc(50), z(50); z.Modify("2*x-1");
yc.Modify("sin(pi*(2*x-1))"); xc.Modify("cos(pi*2*x-pi)");
gr->SubPlot(2,2,3); gr->Title("3d variant"); gr->Rotate(50,60); gr->Box(); gr->Tube(xc,yc,z,y2,"r");
}
Next: type1 sample, Previous: tube sample, Up: All samples [Contents][Index]
10.135 Sample ‘type0’
Example of ordinary transparency (transptype=0).
MGL code:
call 'prepare2d' alpha on:light on:transptype 0:clf subplot 2 2 0:rotate 50 60:surf a:box subplot 2 2 1:rotate 50 60:dens a:box subplot 2 2 2:rotate 50 60:cont a:box subplot 2 2 3:rotate 50 60:axial a:box
C++ code:
void smgl_type0(mglGraph *gr) // TranspType = 0
{
gr->Alpha(true); gr->Light(true);
mglData a; mgls_prepare2d(&a);
gr->SetTranspType(0); gr->Clf();
gr->SubPlot(2,2,0); gr->Rotate(50,60); gr->Surf(a); gr->Box();
gr->SubPlot(2,2,1); gr->Rotate(50,60); gr->Dens(a); gr->Box();
gr->SubPlot(2,2,2); gr->Rotate(50,60); gr->Cont(a); gr->Box();
gr->SubPlot(2,2,3); gr->Rotate(50,60); gr->Axial(a); gr->Box();
}
Next: type2 sample, Previous: type0 sample, Up: All samples [Contents][Index]
10.136 Sample ‘type1’
Example of glass-like transparency (transptype=1).
MGL code:
call 'prepare2d' alpha on:light on:transptype 1:clf subplot 2 2 0:rotate 50 60:surf a:box subplot 2 2 1:rotate 50 60:dens a:box subplot 2 2 2:rotate 50 60:cont a:box subplot 2 2 3:rotate 50 60:axial a:box
C++ code:
void smgl_type1(mglGraph *gr) // TranspType = 1
{
gr->Alpha(true); gr->Light(true);
mglData a; mgls_prepare2d(&a);
gr->SetTranspType(1); gr->Clf();
gr->SubPlot(2,2,0); gr->Rotate(50,60); gr->Surf(a); gr->Box();
gr->SubPlot(2,2,1); gr->Rotate(50,60); gr->Dens(a); gr->Box();
gr->SubPlot(2,2,2); gr->Rotate(50,60); gr->Cont(a); gr->Box();
gr->SubPlot(2,2,3); gr->Rotate(50,60); gr->Axial(a); gr->Box();
}
Next: vect sample, Previous: type1 sample, Up: All samples [Contents][Index]
10.137 Sample ‘type2’
Example of lamp-like transparency (transptype=2).
MGL code:
call 'prepare2d' alpha on:light on:transptype 2:clf subplot 2 2 0:rotate 50 60:surf a:box subplot 2 2 1:rotate 50 60:dens a:box subplot 2 2 2:rotate 50 60:cont a:box subplot 2 2 3:rotate 50 60:axial a:box
C++ code:
void smgl_type2(mglGraph *gr) // TranspType = 2
{
gr->Alpha(true); gr->Light(true);
mglData a; mgls_prepare2d(&a);
gr->SetTranspType(2); gr->Clf();
gr->SubPlot(2,2,0); gr->Rotate(50,60); gr->Surf(a); gr->Box();
gr->SubPlot(2,2,1); gr->Rotate(50,60); gr->Dens(a); gr->Box();
gr->SubPlot(2,2,2); gr->Rotate(50,60); gr->Cont(a); gr->Box();
gr->SubPlot(2,2,3); gr->Rotate(50,60); gr->Axial(a); gr->Box();
}
Next: vect3 sample, Previous: type2 sample, Up: All samples [Contents][Index]
10.138 Sample ‘vect’
Function vect is most standard way to visualize vector fields – it draw a lot of arrows or hachures for each data cell. It have a lot of options which can be seen on the figure (and in the sample code), and use color scheme for coloring (see Color scheme).
MGL code:
call 'prepare2v' call 'prepare3v' subplot 3 2 0 '':title 'Vect plot (default)':box:vect a b subplot 3 2 1 '':title '"." style; "=" style':box:vect a b '.=' subplot 3 2 2 '':title '"f" style':box:vect a b 'f' subplot 3 2 3 '':title '">" style':box:vect a b '>' subplot 3 2 4 '':title '"<" style':box:vect a b '<' subplot 3 2 5:title '3d variant':rotate 50 60:box:vect ex ey ez
C++ code:
void smgl_vect3(mglGraph *gr)
{
mglData ex,ey,ez; mgls_prepare3v(&ex,&ey,&ez);
if(big!=3) { gr->SubPlot(2,1,0); gr->Title("Vect3 sample"); }
gr->Rotate(50,60); gr->SetOrigin(0,0,0); gr->Axis("_xyz"); gr->Box();
gr->Vect3(ex,ey,ez,"x"); gr->Vect3(ex,ey,ez); gr->Vect3(ex,ey,ez,"z");
if(big==3) return;
gr->SubPlot(2,1,1); gr->Title("'f' style");
gr->Rotate(50,60); gr->SetOrigin(0,0,0); gr->Axis("_xyz"); gr->Box();
gr->Vect3(ex,ey,ez,"fx"); gr->Vect3(ex,ey,ez,"f"); gr->Vect3(ex,ey,ez,"fz");
gr->Grid3(ex,"Wx"); gr->Grid3(ex,"W"); gr->Grid3(ex,"Wz");
}
Next: venn sample, Previous: vect sample, Up: All samples [Contents][Index]
10.139 Sample ‘vect3’
Function vect3 draw ordinary vector field plot but at slices of 3D data.
MGL code:
call 'prepare3v' subplot 2 1 0:title 'Vect3 sample':rotate 50 60 origin 0 0 0:box:axis '_xyz' vect3 ex ey ez 'x':vect3 ex ey ez:vect3 ex ey ez 'z' subplot 2 1 1:title '"f" style':rotate 50 60 origin 0 0 0:box:axis '_xyz' vect3 ex ey ez 'fx':vect3 ex ey ez 'f':vect3 ex ey ez 'fz' grid3 ex 'Wx':grid3 ex 'W':grid3 ex 'Wz'
C++ code:
void smgl_vect3(mglGraph *gr)
{
mglData ex,ey,ez; mgls_prepare3v(&ex,&ey,&ez);
if(big!=3) { gr->SubPlot(2,1,0); gr->Title("Vect3 sample"); }
gr->Rotate(50,60); gr->SetOrigin(0,0,0); gr->Axis("_xyz"); gr->Box();
gr->Vect3(ex,ey,ez,"x"); gr->Vect3(ex,ey,ez); gr->Vect3(ex,ey,ez,"z");
if(big==3) return;
gr->SubPlot(2,1,1); gr->Title("'f' style");
gr->Rotate(50,60); gr->SetOrigin(0,0,0); gr->Axis("_xyz"); gr->Box();
gr->Vect3(ex,ey,ez,"fx"); gr->Vect3(ex,ey,ez,"f"); gr->Vect3(ex,ey,ez,"fz");
gr->Grid3(ex,"Wx"); gr->Grid3(ex,"W"); gr->Grid3(ex,"Wz");
}
Previous: vect3 sample, Up: All samples [Contents][Index]
10.140 Sample ’venn’
Example of venn-like diagram.
MGL code:
list x -0.3 0 0.3:list y 0.3 -0.3 0.3:list e 0.7 0.7 0.7 subplot 1 1 0:title 'Venn-like diagram' transptype 1:alpha on:error x y e e '!rgb@#o';alpha 0.1
C++ code:
void smgl_venn(mglGraph *gr)
{
double xx[3]={-0.3,0,0.3}, yy[3]={0.3,-0.3,0.3}, ee[3]={0.7,0.7,0.7};
mglData x(3,xx), y(3,yy), e(3,ee);
gr->SubPlot(1,1,0); gr->Title("Venn-like diagram");
gr->SetTranspType(1); gr->Alpha(true); gr->Error(x,y,e,e,"!rgb@#o","alpha 0.1");
}
Next: File formats, Previous: All samples, Up: Top [Contents][Index]
Appendix A Symbols and hot-keys
This appendix contain the full list of symbols (characters) used by MathGL for setting up plot. Also it contain sections for full list of hot-keys supported by mglview tool and by UDAV program.
| • Symbols for styles: | ||
| • Hot-keys for mglview: | ||
| • Hot-keys for UDAV: |
Next: Hot-keys for mglview, Up: Symbols and hot-keys [Contents][Index]
A.1 Symbols for styles
Below is full list of all characters (symbols) which MathGL use for setting up the plot.
- ‘space ' '’
empty line style (see Line styles);
empty color in chart.
- ‘!’
set to use new color from palette for each point (not for each curve, as default) in 1D plotting;
set to disable ticks tuning in axis and colorbar;
set to draw grid lines at subticks coordinates too;
define complex variable/expression in MGL script if placed at beginning.
- ‘#’
set to use solid marks (see Line styles) or solid error boxes;
set to draw wired plot for axial, surf3, surf3a, surf3c, triplot, quadplot, area, region, bars, barh, tube, tape, cone, boxs and draw boundary only for circle, ellipse, rhomb;
set to draw also mesh lines for surf, surfc, surfa, dens, densx, densy, densz, dens3, or boundary for chart, facex, facey, facez, rect;
set to draw boundary and box for legend, title, or grid lines for table;
set to draw grid for radar;
set to start flow threads and pipes from edges only for flow, pipe;
set to use whole are for axis range in subplot, inplot;
change text color inside a string (see Font styles);
start comment in MGL scripts or in Command options.
- ‘$’
denote parameter of MGL scripts.
- ‘%’
set color scheme along 2 coordinates Color scheme;
operation in Textual formulas.
- ‘&’
-
set to pass long integer number in tick template xtick, ytick, ztick, ctick;
specifier of drawing user-defined symbols as mark (see Line styles);
operation in Textual formulas.
- ‘’’
denote string in MGL scripts or in Command options.
- ‘*’
one of marks (see Line styles);
one of mask for face filling (see Color scheme);
set to start flow threads from 2d array inside data (see flow);
operation in Textual formulas.
- ‘+’
one of marks (see Line styles) or kind of error boxes;
one of mask for face filling (see Color scheme);
set to print ‘+’ for positive numbers in axis, label, table;
operation of increasing last character value in MGL strings;
operation in Textual formulas.
- ‘,’
separator for color positions (see Color styles) or items in a list
concatenation of MGL string with another string or numerical value.
- ‘-’
solid line style (see Line styles);
one of mask for face filling (see Color scheme);
place entries horizontally in legend;
set to use usual ‘-’ for negative numbers in axis, label, table;
operation in Textual formulas.
- ‘.’
one of marks (see Line styles) or kind of error boxes;
set to draw hachures instead of arrows for vect, vect3;
set to use dots instead of faces for cloud, torus, axial, surf3, surf3a, surf3c, surf, surfa, surfc, dens, map;
delimiter of fractional parts for numbers.
- ‘/’
operation in Textual formulas.
- ‘:’
line dashing style (see Line styles);
stop color scheme parsing (see Color scheme);
range operation in MGL scripts;
style for axis;
separator of commands in MGL scripts.
- ‘;’
line dashing style (see Line styles);
one of mask for face filling (see Color scheme);
start of an option in MGL scripts or in Command options;
separator of equations in ode;
separator of labels in iris.
- ‘<’
one of marks (see Line styles);
one of mask for face filling (see Color scheme);
set position of colorbar;
align left in bars, barh, boxplot, cones, candle, ohlc;
operation in Textual formulas.
- ‘>’
one of marks (see Line styles);
one of mask for face filling (see Color scheme);
set position of colorbar;
align right in bars, barh, boxplot, cones, candle, ohlc;
operation in Textual formulas.
- ‘=’
line dashing style (see Line styles);
one of mask for face filling (see Color scheme);
set to use equidistant columns for table;
set to use color gradient for vect, vect3;
operation in Textual formulas.
- ‘@’
set to draw box around text for text and similar functions;
set to draw boundary and fill it for circle, ellipse, rhomb;
set to fill faces for box;
set to draw large semitransparent mark instead of error box for error;
set to draw edges for cone;
set to draw filled boxes for boxs;
reduce text size inside a string (see Font styles);
operation in Textual formulas.
- ‘^’
one of marks (see Line styles);
one of mask for face filling (see Color scheme);
set position of colorbar;
set outer position for legend;
inverse default position for axis;
switch to upper index inside a string (see Font styles);
align center in bars, barh, boxplot, cones, candle, ohlc;
operation in Textual formulas.
- ‘_’
empty arrow style (see Line styles);
disable drawing of tick labels for axis;
set position of colorbar;
set to draw contours at bottom for cont, contf, contd, contv, tricont;
switch to lower index inside a string (see Font styles).
- ‘[]’
contain symbols excluded from color scheme parsing (see Color scheme);
operation of getting n-th character from MGL string.
- ‘{}’
contain extended specification of color (see Color styles), dashing (see Line styles) or mask (see Color scheme);
denote special operation in MGL scripts;
denote ’meta-symbol’ for LaTeX like string parsing (see Font styles).
- ‘|’
line dashing style (see Line styles);
set to use sharp color scheme (see Color scheme);
set to limit width by subplot width for table;
delimiter in list command;
operation in Textual formulas.
- ‘\’
string continuation symbol on next line for MGL scripts.
- ‘~’
disable drawing of tick labels for axis and colorbar;
disable first segment in lamerey;
reduce number of segments in plot and tens;
one of mask for face filling (see Color scheme).
- ‘0,1,2,3,4,5,6,7,8,9’
line width (see Line styles);
brightness of a color (see Color styles);
precision of numbers in axis, label, table;
kind of smoothing (for digits 1,3,5) in smooth;
digits for a value.
- ‘4,6,8’
set to draw square, hex- or octo-pyramids instead of cones in cone, cones.
- ‘A,B,C,D,E,F,a,b,c,d,e,f’
can be hex-digit for color specification if placed inside {} (see Color styles).
- ‘A’
arrow style (see Line styles);
set to use absolute position in whole picture for text, colorbar, legend.
- ‘a’
set to use absolute position in subplot for text;
style of plot, radar, tens, area, region to draw segments between points outside of axis range;
- ‘B’
dark blue color (see Color styles).
- ‘b’
blue color (see Color styles);
bold font face if placed after ‘:’ (see Font styles).
- ‘C’
dark cyan color (see Color styles);
align text to center if placed after ‘:’ (see Font styles).
- ‘c’
cyan color (see Color styles);
name of color axis;
cosine transform for transform.
- ‘D’
arrow style (see Line styles);
one of mask for face filling (see Color scheme).
- ‘d’
one of marks (see Line styles) or kind of error boxes;
one of mask for face filling (see Color scheme);
start hex-dash description if placed inside {} (see Line styles).
- ‘E’
dark green-yellow color (see Color styles).
- ‘e’
green-yellow color (see Color styles).
- ‘F’
- ‘f’
-
set fixed format for numbers in axis, label, table;
Fourier transform for transform.
- ‘G’
dark green color (see Color styles).
- ‘g’
green color (see Color styles).
- ‘H’
dark gray color (see Color styles).
- ‘h’
gray color (see Color styles);
Hankel transform for transform.
- ‘I’
arrow style (see Line styles);
set colorbar position near boundary.
- ‘i’
line dashing style (see Line styles);
italic font face if placed after ‘:’ (see Font styles).
set to use inverse values for cloud, pipe, dew;
set to fill only area with y1<y<y2 for region;
inverse Fourier transform for transform, transforma, fourier.
- ‘j’
line dashing style (see Line styles);
one of mask for face filling (see Color scheme).
- ‘K’
arrow style (see Line styles).
- ‘k’
black color (see Color styles).
- ‘L’
dark green-blue color (see Color styles);
align text to left if placed after ‘:’ (see Font styles).
- ‘l’
green-blue color (see Color styles).
- ‘M’
dark magenta color (see Color styles).
- ‘m’
magenta color (see Color styles).
- ‘N’
dark sky-blue color (see Color styles).
- ‘n’
sky-blue color (see Color styles).
- ‘O’
arrow style (see Line styles);
one of mask for face filling (see Color scheme).
- ‘o’
one of marks (see Line styles) or kind of error boxes;
one of mask for face filling (see Color scheme);
over-line text if placed after ‘:’ (see Font styles).
- ‘P’
dark purple color (see Color styles).
- ‘p’
purple color (see Color styles).
- ‘Q’
dark orange or brown color (see Color styles).
- ‘q’
orange color (see Color styles).
- ‘R’
dark red color (see Color styles);
align text to right if placed after ‘:’ (see Font styles).
- ‘r’
red color (see Color styles).
- ‘S’
arrow style (see Line styles);
one of mask for face filling (see Color scheme).
- ‘s’
one of marks (see Line styles) or kind of error boxes;
one of mask for face filling (see Color scheme);
start hex-mask description if placed inside {} (see Color scheme);
sine transform for transform.
- ‘t’
- ‘T’
arrow style (see Line styles);
- ‘t’
set to draw text labels for cont, cont3;
name of t-axis (one of ternary axis);
variable in Textual formulas, which usually is varied in range [0,1].
- ‘U’
dark blue-violet color (see Color styles);
disable rotation of tick labels for axis.
- ‘u’
blue-violet color (see Color styles);
under-line text if placed after ‘:’ (see Font styles);
name of u-axis (one of ternary axis);
variable in Textual formulas, which usually denote array itself.
- ‘V’
arrow style (see Line styles);
place text centering on vertical direction for text.
- ‘v’
one of marks (see Line styles);
set to draw vectors on flow threads for flow and on segments for lamerey.
- ‘W’
bright gray color (see Color styles).
- ‘w’
white color (see Color styles);
wired text if placed after ‘:’ (see Font styles);
name of w-axis (one of ternary axis);
- ‘X’
arrow style (see Line styles).
- ‘x’
-
name of x-axis or x-direction or 1st dimension of a data array;
start hex-color description if placed inside {} (see Color styles);
one of marks (see Line styles) or kind of error boxes;
tiles orientation perpendicular to x-axis in tile, tiles;
style of tape.
- ‘Y’
dark yellow or gold color (see Color styles).
- ‘y’
yellow color (see Color styles);
name of y-axis or y-direction or 2nd dimension of a data array;
- ‘z’
-
name of z-axis or z-direction or 3d dimension of a data array;
style of tape.
Next: Hot-keys for UDAV, Previous: Symbols for styles, Up: Symbols and hot-keys [Contents][Index]
A.2 Hot-keys for mglview
| Key | Description |
|---|---|
| Ctrl-P | Open printer dialog and print graphics. |
| Ctrl-W | Close window. |
| Ctrl-T | Switch on/off transparency for the graphics. |
| Ctrl-L | Switch on/off additional lightning for the graphics. |
| Ctrl-Space | Restore default graphics rotation, zoom and perspective. |
| F5 | Execute script and redraw graphics. |
| F6 | Change canvas size to fill whole region. |
| F7 | Stop drawing and script execution. |
| Ctrl-F5 | Run slideshow. If no parameter specified then the dialog with slideshow options will appear. |
| Ctrl-Comma, Ctrl-Period | Show next/previous slide. If no parameter specified then the dialog with slideshow options will appear. |
| Ctrl-Shift-G | Copy graphics to clipboard. |
| Alt-P | Export as semitransparent PNG. |
| Alt-F | Export as solid PNG. |
| Alt-J | Export as JPEG. |
| Alt-E | Export as vector EPS. |
| Alt-S | Export as vector SVG. |
| Alt-L | Export as LaTeX/Tikz image. |
| Alt-M | Export as MGLD. |
| Alt-D | Export as PRC/PDF. |
| Alt-O | Export as OBJ. |
Previous: Hot-keys for mglview, Up: Symbols and hot-keys [Contents][Index]
A.3 Hot-keys for UDAV
| Key | Description |
|---|---|
| Ctrl-N | Create new window with empty script. Note, all scripts share variables. So, second window can be used to see some additional information of existed variables. |
| Ctrl-O | Open and execute/show script or data from file. You may switch off automatic exection in UDAV properties |
| Ctrl-S | Save script to a file. |
| Ctrl-P | Open printer dialog and print graphics. |
| Ctrl-Z | Undo changes in script editor. |
| Ctrl-Shift-Z | Redo changes in script editor. |
| Ctrl-X | Cut selected text into clipboard. |
| Ctrl-C | Copy selected text into clipboard. |
| Ctrl-V | Paste selected text from clipboard. |
| Ctrl-A | Select all text in editor. |
| Ctrl-F | Show dialog for text finding. |
| F3 | Find next occurrence of the text. |
| Win-C or Meta-C | Show dialog for new command and put it into the script. |
| Win-F or Meta-F | Insert last fitted formula with found coefficients. |
| Win-S or Meta-S | Show dialog for styles and put it into the script. Styles define the plot view (color scheme, marks, dashing and so on). |
| Win-O or Meta-O | Show dialog for options and put it into the script. Options are used for additional setup the plot. |
| Win-N or Meta-N | Replace selected expression by its numerical value. |
| Win-P or Meta-P | Select file and insert its file name into the script. |
| Win-G or Meta-G | Show dialog for plot setup and put resulting code into the script. This dialog setup axis, labels, lighting and other general things. |
| Ctrl-Shift-O | Load data from file. Data will be deleted only at exit but UDAV will not ask to save it. |
| Ctrl-Shift-S | Save data to a file. |
| Ctrl-Shift-C | Copy range of numbers to clipboard. |
| Ctrl-Shift-V | Paste range of numbers from clipboard. |
| Ctrl-Shift-N | Recreate the data with new sizes and fill it by zeros. |
| Ctrl-Shift-R | Resize (interpolate) the data to specified sizes. |
| Ctrl-Shift-T | Transform data along dimension(s). |
| Ctrl-Shift-M | Make another data. |
| Ctrl-Shift-H | Find histogram of data. |
| Ctrl-T | Switch on/off transparency for the graphics. |
| Ctrl-L | Switch on/off additional lightning for the graphics. |
| Ctrl-G | Switch on/off grid of absolute coordinates. |
| Ctrl-Space | Restore default graphics rotation, zoom and perspective. |
| F5 | Execute script and redraw graphics. |
| F6 | Change canvas size to fill whole region. |
| F7 | Stop script execution and drawing. |
| F8 | Show/hide tool window with list of hidden plots. |
| F9 | Restore status for ’once’ command and reload data. |
| Ctrl-F5 | Run slideshow. If no parameter specified then the dialog with slideshow options will appear. |
| Ctrl-Comma, Ctrl-Period | Show next/previous slide. If no parameter specified then the dialog with slideshow options will appear. |
| Ctrl-W | Open dialog with slideshow options. |
| Ctrl-Shift-G | Copy graphics to clipboard. |
| F1 | Show help on MGL commands |
| F2 | Show/hide tool window with messages and information. |
| F4 | Show/hide calculator which evaluate and help to type textual formulas. Textual formulas may contain data variables too. |
| Meta-Shift-Up, Meta-Shift-Down | Change view angle \theta. |
| Meta-Shift-Left, Meta-Shift-Right | Change view angle \phi. |
| Alt-Minus, Alt-Equal | Zoom in/out whole image. |
| Alt-Up, Alt-Down, Alt-Right, Alt-Left | Shift whole image. |
| Alt-P | Export as semitransparent PNG. |
| Alt-F | Export as solid PNG. |
| Alt-J | Export as JPEG. |
| Alt-E | Export as vector EPS. |
| Alt-S | Export as vector SVG. |
| Alt-L | Export as LaTeX/Tikz image. |
| Alt-M | Export as MGLD. |
| Alt-D | Export as PRC/PDF. |
| Alt-O | Export as OBJ. |
Next: Plotting time, Previous: Symbols and hot-keys, Up: Top [Contents][Index]
Appendix B File formats
This appendix contain description of file formats used by MathGL.
| • Font files: | ||
| • MGLD format: | ||
| • JSON format: | ||
| • IFS format: |
Next: MGLD format, Up: File formats [Contents][Index]
B.1 Font files
Starting from v.1.6 the MathGL library uses new font files. The font is defined in 4 files with suffixes ‘*.vfm’, ‘*_b.vfm’, ‘*_i.vfm’, ‘*_bi.vfm’. These files are text files containing the data for roman font, bold font, italic font and bold italic font. The files (or some symbols in the files) for bold, italic or bold italic fonts can be absent. In this case the roman glyph will be used for them. By analogy, if the bold italic font is absent but the bold font is present then bold glyph will be used for bold italic. You may create these font files by yourself from *.ttf, *.otf files with the help of program font_tools. This program can be found at MathGL home site.
The format of font files (*.vfm – vector font for MathGL) is the following.
- First string contains human readable comment and is always ignored.
- Second string contains 3 numbers, delimited by space or tabulation. The order of numbers is the following: numg – the number of glyphs in the file (integer), fact – the factor for glyph sizing (mreal), size – the size of buffer for glyph description (integer).
- After it numg-th strings with glyphs description are placed. Each string contains 6 positive numbers, delimited by space of tabulation. The order of numbers is the following: Unicode glyph ID, glyph width, number of lines in glyph, position of lines coordinates in the buffer (length is 2*number of lines), number of triangles in glyph, position of triangles coordinates in the buffer (length is 6*number of triangles).
- The end of file contains the buffer with point coordinates at lines or triangles vertexes. The size of buffer (the number of integer) is size.
Each font file can be compressed by gzip.
Note: the closing contour line is done automatically (so the last segment may be absent). For starting new contour use a point with coordinates {0x3fff, 0x3fff}.
Next: JSON format, Previous: Font files, Up: File formats [Contents][Index]
B.2 MGLD format
MGLD is textual file, which contain all required information for drawing 3D image, i.e. it contain vertexes with colors and normales, primitives with all properties, textures, and glyph descriptions. MGLD file can be imported or viewed separately, without parsing data files itself.
MGLD file start from string
MGLD npnts nprim ntxtr nglfs # optional description
which contain signature ‘MGLD’ and number of points npnts, number of primitives nprim, number of textures ntxtr, number of glyph descriptions nglfs, and optional description. Empty strings and string with ‘#’ are ignored.
Next, file contain npnts strings with points coordinates and colors. The format of each string is
x y z c t ta u v w r g b a
Here x, y, z are coordinates, c, t are color indexes in texture, ta is normalized t according to current alpha setting, u, v, w are coordinates of normal vector (can be NAN if disabled), r, g, b, a are RGBA color values.
Next, file contain nprim strings with properties of primitives. The format of each string is
type n1 n2 n3 n4 id s w p
Here type is kind of primitive (0 - mark, 1 - line, 2 - triangle, 3 - quadrangle, 4 - glyph), n1...n4 is index of point for vertexes, id is primitive identification number, s and w are size and width if applicable, p is scaling factor for glyphs.
Next, file contain ntxtr strings with descriptions of textures. The format of each string is
smooth alpha colors
Here smooth set to enable smoothing between colors, alpha set to use half-transparent texture, colors contain color scheme itself as it described in Color scheme.
Finally, file contain nglfs entries with description of each glyph used in the figure. The format of entries are
nT nL xA yA xB yB xC yC ... xP yP ...
Here nT is the number of triangles; nL is the number of line vertexes; xA, yA, xB, yB, xC, yC are coordinates of triangles; and xP, yP, xQ, yQ are coordinates of lines. Line coordinate xP=0x3fff, yP=0x3fff denote line breaking.
Next: IFS format, Previous: MGLD format, Up: File formats [Contents][Index]
B.3 JSON format
MathGL can save points and primitives of 3D object. It contain a set of variables listed below.
- ‘width’
width of the image;
- ‘height’
height of the image
- ‘depth’
depth of the image, usually =sqrt(width*height);
- ‘npnts’
number of points (vertexes);
- ‘pnts’
array of coordinates of points (vertexes), each element is array in form [x, y, z];
- ‘nprim’
number of primitives;
- ‘prim’
array of primitives, each element is array in form [type, n1, n2, n3, n4, id, s, w, p, z, color].
Here type is kind of primitive (0 - mark, 1 - line, 2 - triangle, 3 - quadrangle, 4 - glyph), n1...n4 is index of point for vertexes and n2 can be index of glyph coordinate, s and w are size and width if applicable, z is average z-coordinate, id is primitive identification number, p is scaling factor for glyphs.
- ‘ncoor’
number of glyph positions
- ‘coor’
array of glyph positions, each element is array in form [dx,dy]
- ‘nglfs’
number of glyph descriptions
- ‘glfs’
array of glyph descriptions, each element is array in form
[nL, [xP0, yP0, xP1, yP1 ...]]. HerenLis the number of line vertexes; andxP, yP, xQ, yQare coordinates of lines. Line coordinate xP=0x3fff, yP=0x3fff denote line breaking.
Previous: JSON format, Up: File formats [Contents][Index]
B.4 IFS format
MathGL can read IFS fractal parameters (see ifsfile) from a IFS file. Let remind IFS file format. File may contain several records. Each record contain the name of fractal (‘binary’ in the example below) and the body of fractal, which is enclosed in curly braces {}. Symbol ‘;’ start the comment. If the name of fractal contain ‘(3D)’ or ‘(3d)’ then the 3d IFS fractal is specified. The sample below contain two fractals: ‘binary’ – usual 2d fractal, and ‘3dfern (3D)’ – 3d fractal.
binary
{ ; comment allowed here
; and here
.5 .0 .0 .5 -2.563477 -0.000003 .333333 ; also comment allowed here
.5 .0 .0 .5 2.436544 -0.000003 .333333
.0 -.5 .5 .0 4.873085 7.563492 .333333
}
3dfern (3D) {
.00 .00 0 .0 .18 .0 0 0.0 0.00 0 0.0 0 .01
.85 .00 0 .0 .85 .1 0 -0.1 0.85 0 1.6 0 .85
.20 -.20 0 .2 .20 .0 0 0.0 0.30 0 0.8 0 .07
-.20 .20 0 .2 .20 .0 0 0.0 0.30 0 0.8 0 .07
}
Next: TeX-like symbols, Previous: File formats, Up: Top [Contents][Index]
Appendix C Время отрисовки
В таблице показаны времена создания графика для всех примеров из файла examples/samples.cpp. Тест выполнен на моем ноутбуке (i5-2430M) с 64-bit Debian.
Несколько слов о скорости. Во-первых, прямое рисование в память (Quality=4,5,6) быстрее буферизованного (Quality=0,1,2), но иногда результат некоректен (см. cloud) и пропадает возможность экспорта в векторные и 3d форматы (например, EPS, SVG, PDF, ...). Во-вторых, обычно картинка худшего качества рисуется быстрее, т.е. Quality=1 быстрее Quality=2, и Quality=0 быстрее Quality=1. Однако, если график содержит множество граней (например cloud, surf3, pipe, dew), то Quality=0 может быть достаточно медленным, особенно для маленьких картинок. Наконец, картинки меньшего размера рисуются быстрее.
Результаты для изображения размером 800*600 (по умолчанию).
| Name | q=0 | q=1 | q=2 | q=4 | q=5 | q=6 | q=8 |
|---|---|---|---|---|---|---|---|
| 3wave | 0.0322 | 0.0627 | 0.0721 | 0.0425 | 0.11 | 0.136 | 0.0271 |
| alpha | 0.0892 | 0.108 | 0.113 | 0.0473 | 0.124 | 0.145 | 0.0297 |
| apde | 48.2 | 47.4 | 47.6 | 47.4 | 47.8 | 48.4 | 47.9 |
| area | 0.0376 | 0.0728 | 0.0752 | 0.033 | 0.141 | 0.165 | 0.0186 |
| aspect | 0.0442 | 0.0572 | 0.0551 | 0.031 | 0.0999 | 0.103 | 0.0146 |
| axial | 0.639 | 0.917 | 0.926 | 0.195 | 0.525 | 0.552 | 0.119 |
| axis | 0.0683 | 0.107 | 0.108 | 0.0466 | 0.196 | 0.202 | 0.0169 |
| barh | 0.0285 | 0.0547 | 0.0603 | 0.0292 | 0.101 | 0.115 | 0.0114 |
| bars | 0.0414 | 0.0703 | 0.0843 | 0.1 | 0.185 | 0.184 | 0.0295 |
| belt | 0.0286 | 0.0532 | 0.0577 | 0.0384 | 0.0735 | 0.1 | 0.0131 |
| bifurcation | 0.589 | 0.635 | 0.609 | 0.531 | 0.572 | 0.579 | 0.512 |
| box | 0.0682 | 0.0805 | 0.0828 | 0.0314 | 0.124 | 0.121 | 0.0169 |
| boxplot | 0.0102 | 0.0317 | 0.0347 | 0.02 | 0.0499 | 0.0554 | 0.0167 |
| boxs | 0.239 | 0.363 | 0.4 | 0.0798 | 0.216 | 0.234 | 0.0721 |
| candle | 0.0286 | 0.0549 | 0.053 | 0.0263 | 0.0483 | 0.0564 | 0.0109 |
| chart | 0.416 | 0.613 | 0.707 | 0.26 | 1.07 | 1.59 | 0.191 |
| cloud | 0.0312 | 4.15 | 4.11 | 0.0306 | 0.715 | 0.924 | 0.0168 |
| colorbar | 0.108 | 0.172 | 0.177 | 0.0787 | 0.258 | 0.266 | 0.0452 |
| combined | 0.36 | 0.336 | 0.332 | 0.198 | 0.316 | 0.33 | 0.196 |
| cones | 0.145 | 0.139 | 0.14 | 0.0937 | 0.248 | 0.276 | 0.0363 |
| cont | 0.0987 | 0.141 | 0.141 | 0.0585 | 0.207 | 0.194 | 0.0455 |
| cont3 | 0.0323 | 0.058 | 0.0587 | 0.0304 | 0.0726 | 0.0837 | 0.0162 |
| cont_xyz | 0.0417 | 0.0585 | 0.0612 | 0.0417 | 0.0833 | 0.0845 | 0.0294 |
| contd | 0.191 | 0.245 | 0.236 | 0.104 | 0.189 | 0.201 | 0.0902 |
| contf | 0.162 | 0.179 | 0.182 | 0.0789 | 0.166 | 0.177 | 0.067 |
| contf3 | 0.123 | 0.12 | 0.134 | 0.065 | 0.123 | 0.155 | 0.0538 |
| contf_xyz | 0.0751 | 0.0922 | 0.111 | 0.0756 | 0.0879 | 0.0956 | 0.0462 |
| contv | 0.0947 | 0.123 | 0.136 | 0.0757 | 0.163 | 0.18 | 0.0469 |
| correl | 0.0339 | 0.0629 | 0.0599 | 0.0288 | 0.115 | 0.138 | 0.0165 |
| curvcoor | 0.112 | 0.164 | 0.171 | 0.0864 | 0.296 | 0.298 | 0.0739 |
| cut | 0.695 | 0.465 | 0.484 | 0.303 | 0.385 | 0.371 | 0.316 |
| dat_diff | 0.0457 | 0.079 | 0.0825 | 0.0346 | 0.136 | 0.158 | 0.0186 |
| dat_extra | 0.175 | 0.181 | 0.173 | 0.0877 | 0.163 | 0.173 | 0.0463 |
| data1 | 2.39 | 1.76 | 1.75 | 1.33 | 1.38 | 1.37 | 1.4 |
| data2 | 1.42 | 1.26 | 1.28 | 1.17 | 1.24 | 1.29 | 1.14 |
| dens | 0.0867 | 0.122 | 0.131 | 0.0615 | 0.145 | 0.168 | 0.032 |
| dens3 | 0.0722 | 0.0769 | 0.0937 | 0.0437 | 0.0947 | 0.151 | 0.0797 |
| dens_xyz | 0.0599 | 0.0875 | 0.0961 | 0.0463 | 0.089 | 0.0897 | 0.0315 |
| detect | 0.133 | 0.151 | 0.176 | 0.0861 | 0.116 | 0.138 | 0.0721 |
| dew | 1.48 | 1.07 | 0.971 | 0.473 | 0.537 | 0.416 | 0.195 |
| diffract | 0.0878 | 0.127 | 0.139 | 0.0607 | 0.219 | 0.237 | 0.0274 |
| dilate | 0.0778 | 0.128 | 0.138 | 0.0592 | 0.242 | 0.232 | 0.0298 |
| dots | 0.0685 | 0.1 | 0.101 | 0.0694 | 0.134 | 0.129 | 0.0261 |
| earth | 0.0147 | 0.033 | 0.0218 | 0.0168 | 0.0168 | 0.0191 | 0.00177 |
| error | 0.0312 | 0.0707 | 0.0709 | 0.0288 | 0.135 | 0.137 | 0.016 |
| error2 | 0.0581 | 0.0964 | 0.0958 | 0.0595 | 0.173 | 0.187 | 0.0444 |
| export | 0.116 | 0.158 | 0.167 | 0.0799 | 0.132 | 0.133 | 0.0685 |
| fall | 0.035 | 0.051 | 0.0577 | 0.018 | 0.0585 | 0.0709 | 0.0142 |
| fexport | 1.52 | 1.76 | 1.78 | 0.278 | 0.604 | 0.606 | 1.35 |
| fit | 0.0371 | 0.0653 | 0.0666 | 0.0277 | 0.081 | 0.0837 | 0.014 |
| flame2d | 5.37 | 5.54 | 5.5 | 3.04 | 3.21 | 3.09 | 1.13 |
| flow | 0.368 | 0.451 | 0.444 | 0.36 | 0.5 | 0.48 | 0.352 |
| fog | 0.0406 | 0.0645 | 0.0688 | 0.0379 | 0.0793 | 0.0894 | 0.0156 |
| fonts | 0.0477 | 0.0926 | 0.112 | 0.0347 | 0.0518 | 0.0519 | 0.0413 |
| grad | 0.0607 | 0.104 | 0.129 | 0.0715 | 0.103 | 0.12 | 0.0633 |
| hist | 0.125 | 0.148 | 0.159 | 0.0919 | 0.116 | 0.129 | 0.0372 |
| ifs2d | 0.594 | 0.623 | 0.62 | 0.315 | 0.349 | 0.33 | 0.109 |
| ifs3d | 0.787 | 0.777 | 0.784 | 0.294 | 0.353 | 0.366 | 0.117 |
| indirect | 0.0286 | 0.0517 | 0.0543 | 0.031 | 0.0612 | 0.104 | 0.0144 |
| inplot | 0.0687 | 0.0979 | 0.0993 | 0.0622 | 0.181 | 0.195 | 0.0444 |
| iris | 0.00846 | 0.025 | 0.0198 | 0.00349 | 0.0172 | 0.0182 | 0.0018 |
| label | 0.0285 | 0.045 | 0.058 | 0.0267 | 0.0525 | 0.0618 | 0.014 |
| lamerey | 0.0305 | 0.0372 | 0.0455 | 0.019 | 0.0604 | 0.0633 | 0.0024 |
| legend | 0.0764 | 0.202 | 0.207 | 0.0455 | 0.138 | 0.148 | 0.0162 |
| light | 0.0903 | 0.129 | 0.122 | 0.0573 | 0.132 | 0.144 | 0.021 |
| loglog | 0.103 | 0.168 | 0.16 | 0.0806 | 0.228 | 0.235 | 0.0802 |
| map | 0.0303 | 0.0653 | 0.0721 | 0.0337 | 0.0821 | 0.0866 | 0.015 |
| mark | 0.0191 | 0.0324 | 0.0368 | 0.0261 | 0.0533 | 0.045 | 0.0072 |
| mask | 0.0442 | 0.0964 | 0.101 | 0.0343 | 0.205 | 0.211 | 0.0115 |
| mesh | 0.034 | 0.0774 | 0.0682 | 0.0192 | 0.0765 | 0.0742 | 0.0145 |
| mirror | 0.092 | 0.128 | 0.142 | 0.0607 | 0.174 | 0.176 | 0.0312 |
| molecule | 0.0827 | 0.0842 | 0.0859 | 0.0443 | 0.0997 | 0.146 | 0.0115 |
| ode | 0.149 | 0.202 | 0.202 | 0.147 | 0.282 | 0.316 | 0.133 |
| ohlc | 0.0059 | 0.0278 | 0.0271 | 0.0152 | 0.0517 | 0.045 | 0.0152 |
| param1 | 0.161 | 0.252 | 0.26 | 0.0941 | 0.301 | 0.341 | 0.0466 |
| param2 | 0.535 | 0.58 | 0.539 | 0.26 | 0.452 | 0.475 | 0.189 |
| param3 | 1.75 | 2.37 | 2.32 | 0.677 | 0.899 | 0.907 | 0.758 |
| paramv | 1.21 | 1.39 | 1.36 | 0.788 | 0.974 | 0.968 | 0.69 |
| parser | 0.0346 | 0.0582 | 0.0687 | 0.0317 | 0.108 | 0.11 | 0.0275 |
| pde | 0.329 | 0.358 | 0.373 | 0.272 | 0.311 | 0.364 | 0.264 |
| pendelta | 0.0653 | 0.0525 | 0.0648 | 0.0517 | 0.0531 | 0.0522 | 0.0653 |
| pipe | 0.598 | 0.737 | 0.738 | 0.382 | 0.493 | 0.505 | 0.34 |
| plot | 0.0397 | 0.0642 | 0.114 | 0.0444 | 0.123 | 0.118 | 0.0194 |
| pmap | 0.0913 | 0.115 | 0.125 | 0.0572 | 0.0999 | 0.113 | 0.0469 |
| primitives | 0.0581 | 0.108 | 0.128 | 0.0649 | 0.181 | 0.21 | 0.00928 |
| projection | 0.13 | 0.264 | 0.286 | 0.0704 | 0.351 | 0.349 | 0.0683 |
| projection5 | 0.117 | 0.207 | 0.215 | 0.0717 | 0.3 | 0.312 | 0.0437 |
| pulse | 0.0273 | 0.0395 | 0.0413 | 0.0183 | 0.0576 | 0.0635 | 0.0023 |
| qo2d | 0.218 | 0.246 | 0.274 | 0.198 | 0.243 | 0.255 | 0.177 |
| quality0 | 0.0859 | 0.0902 | 0.087 | 0.0808 | 0.0808 | 0.0823 | 0.0796 |
| quality1 | 0.189 | 0.166 | 0.171 | 0.175 | 0.17 | 0.173 | 0.166 |
| quality2 | 0.183 | 0.183 | 0.175 | 0.172 | 0.171 | 0.183 | 0.184 |
| quality4 | 0.082 | 0.0713 | 0.0728 | 0.0636 | 0.0843 | 0.0651 | 0.0592 |
| quality5 | 0.366 | 0.359 | 0.363 | 0.366 | 0.354 | 0.356 | 0.357 |
| quality6 | 0.373 | 0.367 | 0.365 | 0.366 | 0.368 | 0.383 | 0.366 |
| quality8 | 0.0193 | 0.019 | 0.0289 | 0.0298 | 0.0165 | 0.0244 | 0.0229 |
| radar | 0.0193 | 0.0369 | 0.0545 | 0.0158 | 0.0525 | 0.0532 | 0.0115 |
| refill | 0.153 | 0.168 | 0.166 | 0.0746 | 0.239 | 0.258 | 0.0467 |
| region | 0.0396 | 0.0723 | 0.0859 | 0.0342 | 0.133 | 0.159 | 0.017 |
| scanfile | 0.0315 | 0.036 | 0.0497 | 0.0169 | 0.0486 | 0.053 | 0.014 |
| schemes | 0.0703 | 0.114 | 0.117 | 0.062 | 0.204 | 0.21 | 0.019 |
| section | 0.0294 | 0.0483 | 0.054 | 0.0221 | 0.0804 | 0.0821 | 0.00568 |
| several_light | 0.0441 | 0.0541 | 0.0701 | 0.0299 | 0.0602 | 0.0815 | 0.0117 |
| solve | 0.0461 | 0.109 | 0.105 | 0.0462 | 0.18 | 0.191 | 0.0184 |
| stem | 0.0418 | 0.0599 | 0.0591 | 0.0308 | 0.126 | 0.139 | 0.015 |
| step | 0.0399 | 0.0614 | 0.0554 | 0.0315 | 0.0958 | 0.113 | 0.0145 |
| stereo | 0.0569 | 0.0652 | 0.0811 | 0.031 | 0.0807 | 0.093 | 0.0163 |
| stfa | 0.0425 | 0.117 | 0.111 | 0.0416 | 0.115 | 0.121 | 0.0157 |
| style | 0.0892 | 0.197 | 0.204 | 0.0596 | 0.349 | 0.369 | 0.0158 |
| surf | 0.109 | 0.133 | 0.157 | 0.0657 | 0.16 | 0.158 | 0.0315 |
| surf3 | 1.79 | 2.6 | 2.57 | 0.949 | 2.36 | 2.44 | 0.625 |
| surf3a | 0.431 | 0.281 | 0.297 | 0.176 | 0.235 | 0.252 | 0.178 |
| surf3c | 0.423 | 0.285 | 0.301 | 0.175 | 0.202 | 0.265 | 0.177 |
| surf3ca | 0.428 | 0.303 | 0.31 | 0.176 | 0.203 | 0.265 | 0.19 |
| surfa | 0.0409 | 0.0577 | 0.0714 | 0.0265 | 0.062 | 0.0725 | 0.0154 |
| surfc | 0.0422 | 0.0453 | 0.058 | 0.0282 | 0.0628 | 0.0749 | 0.0161 |
| surfca | 0.0416 | 0.0598 | 0.058 | 0.0254 | 0.0541 | 0.0671 | 0.015 |
| table | 0.103 | 0.213 | 0.214 | 0.0484 | 0.112 | 0.117 | 0.0156 |
| tape | 0.0409 | 0.0784 | 0.0836 | 0.0347 | 0.124 | 0.138 | 0.0164 |
| tens | 0.0329 | 0.0485 | 0.0441 | 0.0279 | 0.0805 | 0.0757 | 0.00561 |
| ternary | 0.104 | 0.218 | 0.214 | 0.0634 | 0.393 | 0.425 | 0.0352 |
| text | 0.0827 | 0.156 | 0.15 | 0.0261 | 0.114 | 0.127 | 0.015 |
| text2 | 0.0719 | 0.12 | 0.131 | 0.115 | 0.129 | 0.137 | 0.016 |
| textmark | 0.0403 | 0.0749 | 0.0788 | 0.0223 | 0.0607 | 0.0653 | 0.014 |
| ticks | 0.0868 | 0.193 | 0.195 | 0.0611 | 0.259 | 0.249 | 0.0275 |
| tile | 0.0349 | 0.0444 | 0.0597 | 0.0308 | 0.0546 | 0.0547 | 0.0111 |
| tiles | 0.0393 | 0.0585 | 0.0534 | 0.0205 | 0.0648 | 0.0597 | 0.0174 |
| torus | 0.114 | 0.197 | 0.193 | 0.0713 | 0.394 | 0.457 | 0.0306 |
| traj | 0.0251 | 0.0413 | 0.043 | 0.0178 | 0.0628 | 0.0968 | 0.0129 |
| triangulation | 0.0328 | 0.0659 | 0.0792 | 0.0319 | 0.0966 | 0.0888 | 0.0155 |
| triplot | 0.0302 | 0.0705 | 0.102 | 0.0198 | 0.0973 | 0.127 | 0.0143 |
| tube | 0.077 | 0.143 | 0.192 | 0.0593 | 0.191 | 0.21 | 0.0197 |
| type0 | 0.177 | 0.172 | 0.198 | 0.0673 | 0.141 | 0.2 | 0.0576 |
| type1 | 0.174 | 0.173 | 0.2 | 0.0648 | 0.153 | 0.17 | 0.0571 |
| type2 | 0.188 | 0.198 | 0.197 | 0.0773 | 0.186 | 0.193 | 0.0647 |
| vect | 0.129 | 0.336 | 0.194 | 0.0608 | 0.174 | 0.177 | 0.043 |
| vect3 | 0.0317 | 0.0781 | 0.0869 | 0.0366 | 0.155 | 0.159 | 0.0174 |
| venn | 0.0153 | 0.0503 | 0.0787 | 0.0115 | 0.0665 | 0.075 | 0.00249 |
Результаты для изображения размером 1920*1440 (для печати)
| Name | q=0 | q=1 | q=2 | q=4 | q=5 | q=6 | q=8 |
|---|---|---|---|---|---|---|---|
| 3wave | 0.0763 | 0.134 | 0.157 | 0.0764 | 0.198 | 0.207 | 0.0598 |
| alpha | 0.111 | 0.176 | 0.254 | 0.104 | 0.244 | 0.272 | 0.0591 |
| apde | 48 | 47.6 | 47.5 | 47.1 | 47.2 | 47.7 | 47 |
| area | 0.0783 | 0.169 | 0.245 | 0.107 | 0.277 | 0.335 | 0.0408 |
| aspect | 0.0622 | 0.105 | 0.129 | 0.0638 | 0.185 | 0.234 | 0.0478 |
| axial | 0.681 | 1.38 | 1.61 | 0.297 | 0.878 | 1.12 | 0.141 |
| axis | 0.0863 | 0.153 | 0.17 | 0.0773 | 0.274 | 0.297 | 0.0479 |
| barh | 0.0631 | 0.118 | 0.134 | 0.0661 | 0.218 | 0.259 | 0.049 |
| bars | 0.0654 | 0.126 | 0.153 | 0.0803 | 0.28 | 0.318 | 0.0479 |
| belt | 0.0624 | 0.11 | 0.133 | 0.0614 | 0.228 | 0.354 | 0.0454 |
| bifurcation | 0.604 | 0.696 | 0.758 | 0.602 | 0.656 | 0.692 | 0.572 |
| box | 0.081 | 0.152 | 0.211 | 0.0754 | 0.204 | 0.238 | 0.0516 |
| boxplot | 0.0458 | 0.072 | 0.108 | 0.0493 | 0.106 | 0.12 | 0.0329 |
| boxs | 0.276 | 0.623 | 0.823 | 0.131 | 0.387 | 0.52 | 0.0935 |
| candle | 0.0566 | 0.1 | 0.113 | 0.059 | 0.126 | 0.154 | 0.0435 |
| chart | 0.46 | 1.08 | 1.78 | 0.377 | 2.57 | 3.84 | 0.19 |
| cloud | 0.0618 | 5.78 | 6.76 | 0.061 | 1.49 | 2.72 | 0.0441 |
| colorbar | 0.144 | 0.259 | 0.297 | 0.142 | 0.383 | 0.455 | 0.075 |
| combined | 0.429 | 0.457 | 0.556 | 0.286 | 0.474 | 0.564 | 0.245 |
| cones | 0.17 | 0.226 | 0.272 | 0.157 | 0.521 | 0.667 | 0.0624 |
| cont | 0.0989 | 0.193 | 0.235 | 0.0952 | 0.285 | 0.304 | 0.0637 |
| cont3 | 0.0645 | 0.11 | 0.122 | 0.0629 | 0.13 | 0.152 | 0.0479 |
| cont_xyz | 0.0676 | 0.105 | 0.129 | 0.0628 | 0.134 | 0.148 | 0.0523 |
| contd | 0.237 | 0.307 | 0.368 | 0.151 | 0.294 | 0.346 | 0.106 |
| contf | 0.193 | 0.262 | 0.305 | 0.136 | 0.274 | 0.322 | 0.0921 |
| contf3 | 0.169 | 0.206 | 0.3 | 0.117 | 0.232 | 0.353 | 0.0796 |
| contf_xyz | 0.118 | 0.18 | 0.206 | 0.103 | 0.177 | 0.231 | 0.0661 |
| contv | 0.131 | 0.226 | 0.259 | 0.114 | 0.282 | 0.334 | 0.0753 |
| correl | 0.0578 | 0.108 | 0.115 | 0.0616 | 0.193 | 0.216 | 0.0463 |
| curvcoor | 0.125 | 0.203 | 0.219 | 0.12 | 0.454 | 0.504 | 0.0933 |
| cut | 0.768 | 0.661 | 0.73 | 0.43 | 0.53 | 0.669 | 0.431 |
| dat_diff | 0.0922 | 0.151 | 0.193 | 0.092 | 0.235 | 0.274 | 0.0439 |
| dat_extra | 0.202 | 0.236 | 0.263 | 0.132 | 0.254 | 0.292 | 0.0747 |
| data1 | 2.62 | 2.07 | 2.14 | 1.43 | 1.69 | 1.83 | 1.56 |
| data2 | 1.51 | 1.41 | 1.49 | 1.22 | 1.43 | 1.44 | 1.24 |
| dens | 0.115 | 0.236 | 0.32 | 0.134 | 0.271 | 0.327 | 0.0746 |
| dens3 | 0.101 | 0.154 | 0.214 | 0.0981 | 0.173 | 0.244 | 0.0429 |
| dens_xyz | 0.102 | 0.179 | 0.242 | 0.119 | 0.164 | 0.22 | 0.0495 |
| detect | 0.17 | 0.283 | 0.357 | 0.129 | 0.217 | 0.293 | 0.0927 |
| dew | 1.63 | 1.1 | 1.19 | 0.557 | 0.797 | 0.881 | 0.288 |
| diffract | 0.0961 | 0.253 | 0.346 | 0.114 | 0.382 | 0.43 | 0.0508 |
| dilate | 0.098 | 0.231 | 0.259 | 0.101 | 0.347 | 0.404 | 0.0539 |
| dots | 0.0986 | 0.139 | 0.167 | 0.106 | 0.24 | 0.221 | 0.223 |
| earth | 0.0455 | 0.0532 | 0.0659 | 0.0448 | 0.0404 | 0.0592 | 0.0294 |
| error | 0.0764 | 0.128 | 0.134 | 0.0758 | 0.203 | 0.227 | 0.076 |
| error2 | 0.0739 | 0.166 | 0.188 | 0.0934 | 0.374 | 0.416 | 0.0608 |
| export | 0.177 | 0.273 | 0.382 | 0.131 | 0.244 | 0.312 | 0.0968 |
| fall | 0.0481 | 0.127 | 0.114 | 0.051 | 0.115 | 0.125 | 0.0442 |
| fexport | 2.33 | 2.69 | 2.81 | 1.12 | 1.43 | 1.52 | 2.19 |
| fit | 0.072 | 0.112 | 0.121 | 0.0657 | 0.154 | 0.166 | 0.0442 |
| flame2d | 6.16 | 6.34 | 6.31 | 3.71 | 3.91 | 3.75 | 1.26 |
| flow | 0.43 | 0.529 | 0.557 | 0.403 | 0.582 | 0.599 | 0.372 |
| fog | 0.0651 | 0.146 | 0.209 | 0.07 | 0.172 | 0.242 | 0.0466 |
| fonts | 0.0842 | 0.13 | 0.135 | 0.0669 | 0.0969 | 0.0965 | 0.0696 |
| grad | 0.111 | 0.223 | 0.318 | 0.133 | 0.216 | 0.284 | 0.0783 |
| hist | 0.185 | 0.227 | 0.25 | 0.136 | 0.234 | 0.253 | 0.0632 |
| ifs2d | 0.7 | 0.777 | 0.762 | 0.396 | 0.457 | 0.443 | 0.133 |
| ifs3d | 0.827 | 0.835 | 0.893 | 0.369 | 0.45 | 0.484 | 0.127 |
| indirect | 0.0579 | 0.0904 | 0.116 | 0.0599 | 0.128 | 0.152 | 0.0316 |
| inplot | 0.0931 | 0.151 | 0.19 | 0.107 | 0.32 | 0.329 | 0.0601 |
| iris | 0.0446 | 0.0544 | 0.0751 | 0.0468 | 0.0457 | 0.0578 | 0.0371 |
| label | 0.0484 | 0.0879 | 0.105 | 0.0601 | 0.112 | 0.164 | 0.078 |
| lamerey | 0.0723 | 0.0728 | 0.0978 | 0.0611 | 0.104 | 0.154 | 0.0522 |
| legend | 0.123 | 0.282 | 0.3 | 0.0796 | 0.232 | 0.311 | 0.041 |
| light | 0.12 | 0.186 | 0.448 | 0.104 | 0.22 | 0.417 | 0.0528 |
| loglog | 0.136 | 0.252 | 0.252 | 0.125 | 0.405 | 0.481 | 0.0956 |
| map | 0.0768 | 0.157 | 0.195 | 0.0734 | 0.168 | 0.232 | 0.0471 |
| mark | 0.0659 | 0.0909 | 0.0881 | 0.0718 | 0.239 | 0.151 | 0.0372 |
| mask | 0.0878 | 0.207 | 0.326 | 0.0944 | 0.279 | 0.347 | 0.0511 |
| mesh | 0.0719 | 0.131 | 0.163 | 0.0683 | 0.147 | 0.181 | 0.0418 |
| mirror | 0.135 | 0.217 | 0.259 | 0.105 | 0.296 | 0.308 | 0.0548 |
| molecule | 0.0979 | 0.146 | 0.237 | 0.0953 | 0.241 | 0.361 | 0.044 |
| ode | 0.193 | 0.28 | 0.29 | 0.191 | 0.419 | 0.436 | 0.163 |
| ohlc | 0.0482 | 0.071 | 0.0936 | 0.0574 | 0.109 | 0.121 | 0.0447 |
| param1 | 0.186 | 0.348 | 0.424 | 0.15 | 0.545 | 0.845 | 0.0861 |
| param2 | 0.57 | 0.732 | 0.806 | 0.313 | 0.698 | 0.827 | 0.23 |
| param3 | 1.91 | 2.56 | 2.93 | 0.767 | 1.17 | 1.58 | 0.844 |
| paramv | 1.29 | 1.55 | 1.5 | 0.816 | 1.12 | 1.11 | 0.718 |
| parser | 0.0631 | 0.112 | 0.14 | 0.0643 | 0.209 | 0.232 | 0.0467 |
| pde | 0.37 | 0.511 | 0.554 | 0.318 | 0.429 | 0.455 | 0.284 |
| pendelta | 0.108 | 0.115 | 0.102 | 0.108 | 0.115 | 0.104 | 0.105 |
| pipe | 0.661 | 0.922 | 1.04 | 0.414 | 0.669 | 0.828 | 0.36 |
| plot | 0.0961 | 0.116 | 0.142 | 0.0932 | 0.22 | 0.237 | 0.0457 |
| pmap | 0.137 | 0.184 | 0.216 | 0.0994 | 0.165 | 0.21 | 0.0737 |
| primitives | 0.0978 | 0.191 | 0.289 | 0.0971 | 0.304 | 0.353 | 0.0386 |
| projection | 0.166 | 0.403 | 0.484 | 0.124 | 0.578 | 0.626 | 0.078 |
| projection5 | 0.149 | 0.323 | 0.36 | 0.117 | 0.496 | 0.546 | 0.0722 |
| pulse | 0.0488 | 0.0751 | 0.0911 | 0.0503 | 0.112 | 0.13 | 0.0347 |
| qo2d | 0.252 | 0.389 | 0.455 | 0.244 | 0.354 | 0.414 | 0.208 |
| quality0 | 0.112 | 0.112 | 0.119 | 0.119 | 0.11 | 0.123 | 0.114 |
| quality1 | 0.239 | 0.254 | 0.24 | 0.24 | 0.252 | 0.26 | 0.232 |
| quality2 | 0.276 | 0.273 | 0.272 | 0.277 | 0.275 | 0.274 | 0.278 |
| quality4 | 0.107 | 0.104 | 0.103 | 0.104 | 0.104 | 0.112 | 0.107 |
| quality5 | 0.455 | 0.448 | 0.46 | 0.466 | 0.45 | 0.45 | 0.456 |
| quality6 | 0.489 | 0.478 | 0.48 | 0.489 | 0.48 | 0.479 | 0.492 |
| quality8 | 0.0575 | 0.0467 | 0.0453 | 0.0439 | 0.047 | 0.0462 | 0.0486 |
| radar | 0.058 | 0.0675 | 0.0872 | 0.07 | 0.0969 | 0.123 | 0.0284 |
| refill | 0.186 | 0.232 | 0.278 | 0.129 | 0.356 | 0.389 | 0.07 |
| region | 0.0706 | 0.166 | 0.21 | 0.0803 | 0.274 | 0.3 | 0.0442 |
| scanfile | 0.0563 | 0.0769 | 0.0884 | 0.0469 | 0.0891 | 0.106 | 0.0341 |
| schemes | 0.121 | 0.227 | 0.283 | 0.189 | 0.284 | 0.338 | 0.0454 |
| section | 0.0593 | 0.0948 | 0.0974 | 0.0622 | 0.159 | 0.175 | 0.0417 |
| several_light | 0.076 | 0.109 | 0.244 | 0.0697 | 0.123 | 0.246 | 0.0442 |
| solve | 0.0925 | 0.188 | 0.195 | 0.108 | 0.344 | 0.334 | 0.0485 |
| stem | 0.0633 | 0.129 | 0.145 | 0.0827 | 0.203 | 0.212 | 0.0407 |
| step | 0.0632 | 0.102 | 0.114 | 0.112 | 0.183 | 0.194 | 0.0447 |
| stereo | 0.0901 | 0.126 | 0.206 | 0.0807 | 0.151 | 0.237 | 0.0441 |
| stfa | 0.0925 | 0.245 | 0.291 | 0.0801 | 0.214 | 0.299 | 0.0438 |
| style | 0.114 | 0.271 | 0.321 | 0.102 | 0.44 | 0.468 | 0.0451 |
| surf | 0.149 | 0.241 | 0.303 | 0.12 | 0.24 | 0.319 | 0.0498 |
| surf3 | 2.01 | 3.41 | 3.44 | 1.41 | 3.34 | 3.33 | 0.667 |
| surf3a | 0.514 | 0.397 | 0.537 | 0.24 | 0.397 | 0.74 | 0.205 |
| surf3c | 0.482 | 0.4 | 0.533 | 0.235 | 0.423 | 0.728 | 0.208 |
| surf3ca | 0.494 | 0.401 | 0.536 | 0.26 | 0.402 | 0.709 | 0.243 |
| surfa | 0.0643 | 0.105 | 0.181 | 0.0572 | 0.122 | 0.192 | 0.0456 |
| surfc | 0.0644 | 0.111 | 0.184 | 0.0609 | 0.128 | 0.199 | 0.0399 |
| surfca | 0.0645 | 0.106 | 0.181 | 0.0696 | 0.128 | 0.201 | 0.044 |
| table | 0.128 | 0.263 | 0.29 | 0.0813 | 0.176 | 0.197 | 0.0481 |
| tape | 0.0779 | 0.143 | 0.167 | 0.0788 | 0.224 | 0.242 | 0.0463 |
| tens | 0.0605 | 0.0956 | 0.0935 | 0.0699 | 0.146 | 0.162 | 0.046 |
| ternary | 0.13 | 0.334 | 0.357 | 0.116 | 0.589 | 0.65 | 0.061 |
| text | 0.11 | 0.214 | 0.225 | 0.0678 | 0.172 | 0.19 | 0.0438 |
| text2 | 0.0809 | 0.175 | 0.189 | 0.0797 | 0.22 | 0.235 | 0.0425 |
| textmark | 0.0742 | 0.129 | 0.14 | 0.0574 | 0.126 | 0.143 | 0.0438 |
| ticks | 0.126 | 0.252 | 0.274 | 0.111 | 0.329 | 0.359 | 0.0488 |
| tile | 0.062 | 0.091 | 0.135 | 0.0605 | 0.11 | 0.156 | 0.0613 |
| tiles | 0.06 | 0.119 | 0.158 | 0.0604 | 0.129 | 0.163 | 0.0466 |
| torus | 0.148 | 0.277 | 0.391 | 0.121 | 0.817 | 1.19 | 0.0653 |
| traj | 0.0476 | 0.0899 | 0.108 | 0.0559 | 0.153 | 0.162 | 0.0336 |
| triangulation | 0.0622 | 0.159 | 0.218 | 0.0667 | 0.173 | 0.244 | 0.0451 |
| triplot | 0.0494 | 0.181 | 0.371 | 0.0608 | 0.181 | 0.32 | 0.0308 |
| tube | 0.108 | 0.286 | 0.373 | 0.104 | 0.311 | 0.379 | 0.0493 |
| type0 | 0.238 | 0.326 | 0.5 | 0.144 | 0.314 | 0.479 | 0.108 |
| type1 | 0.237 | 0.34 | 0.531 | 0.137 | 0.317 | 0.5 | 0.102 |
| type2 | 0.243 | 0.335 | 0.509 | 0.148 | 0.317 | 0.484 | 0.115 |
| vect | 0.11 | 0.248 | 0.328 | 0.127 | 0.354 | 0.325 | 0.0732 |
| vect3 | 0.0692 | 0.153 | 0.173 | 0.0884 | 0.526 | 0.366 | 0.0356 |
| venn | 0.0494 | 0.194 | 0.289 | 0.0664 | 0.158 | 0.236 | 0.044 |
Next: Copying This Manual, Previous: Plotting time, Up: Top [Contents][Index]
Appendix D Символы TeX
The full list of TeX-like commands recognizable by MathGL is shown below. If command is not recognized then it will be printed as is by ommitting ‘\’ symbol. For example, ‘\#’ produce “#”, ‘\\’ produce “\”, ‘\qq’ produce “qq”.
Change case: _, ^, @.
Text style: \big, \b, \textbf, \i, \textit, \bi, \r, \textrm, \a, \overline, \u, \underline, \w, \wire, #, \color[wkrgbcymhRGBCYMHWlenupqLENUPQ]
Roots: \sqrt, \sqrt3, \sqrt4
Fractions: \frac, \dfrac, \stack, \overset, \underset, \stackr, \stackl
Accents: \hat, \tilde, \dot, \ddot, \dddot, \ddddot, \acute, \check, \grave, \vec, \bar, \breve
Special symbols:
\# (#), \% (%), \& (&), \^ (^).
\AA (Å), \AE (Æ), \APLboxquestion (⍰), \APLboxupcaret (⍓), \APLnotbackslash (⍀), \APLnotslash (⌿), \Alpha (Α), \And (&), \Angstrom (Å), \Barv (⫧), \BbbC (ℂ), \BbbGamma (ℾ), \BbbH (ℍ), \BbbN (ℕ), \BbbP (ℙ), \BbbPi (ℿ), \BbbQ (ℚ), \BbbR (ℝ), \BbbZ (ℤ), \Bbbgamma (ℽ), \Bbbpi (ℼ), \Bbbsum (⅀), \Beta (Β), \Bumpeq (≎), \Cap (⋒), \Chi (Χ), \Colon (∷), \Coloneq (⩴), \Cup (⋓), \DDownarrow (⟱), \DH (Ð), \DJ (Đ), \DashV (⫥), \DashVDash (⟚), \Dashv (⫤), \Ddownarrow (⤋), \Delta (Δ), \Digamma (Ϝ), \Doteq (≑), \Downarrow (⇓), \Epsilon (Ε), \Equiv (≣), \Eta (Η), \Eulerconst (ℇ), \Exclam (‼), \Finv (Ⅎ), \Game (⅁), \Gamma (Γ), \Gt (⪢), \Hermaphrodite (⚥), \Im (ℑ), \Iota (Ι), \Kappa (Κ), \Koppa (Ϟ), \L (Ł), \LLeftarrow (⭅), \Lambda (Λ), \Lbrbrak (⟬), \Ldsh (↲), \Leftarrow (⇐), \Leftrightarrow (⇔), \Lleftarrow (⇚), \Longleftarrow (⟸), \Longleftrightarrow (⟺), \Longmapsfrom (⟽), \Longmapsto (⟾), \Longrightarrow (⟹), \Lparengtr (⦕), \Lsh (↰), \Lt (⪡), \Lvzigzag (⧚), \Mapsfrom (⤆), \Mapsto (⤇), \Mu (Μ), \NG (Ŋ), \Nearrow (⇗), \Not (⫬), \Nu (Ν), \Nwarrow (⇖), \O (Ø), \OE (Œ), \Ohorn (Ơ), \Omega (Ω), \Omicron (Ο), \Otimes (⨷), \P (¶), \Phi (Φ), \Pi (Π), \Planckconst (ℎ), \Prec (⪻), \PropertyLine (⅊), \Psi (Ψ), \QED (∎), \Question (⁇), \RRightarrow (⭆), \Rbrbrak (⟭), \Rdsh (↳), \Re (ℜ), \Rho (Ρ), \Rightarrow (⇒), \Rparenless (⦖), \Rrightarrow (⇛), \Rsh (↱), \Rvzigzag (⧛), \S (§), \Sc (⪼), \Searrow (⇘), \Sigma (Σ), \Sqcap (⩎), \Sqcup (⩏), \Stigma (Ϛ), \Subset (⋐), \Supset (⋑), \Swarrow (⇙), \TH (Þ), \Tau (Τ), \Theta (Θ), \UUparrow (⟰), \Uhorn (Ư), \Uparrow (⇑), \Updownarrow (⇕), \Uuparrow (⤊), \VDash (⊫), \Vbar (⫫), \Vdash (⊩), \Vee (⩔), \Vert (‖), \Vvdash (⊪), \Vvert (⦀), \Wedge (⩓), \XBox (☒), \Xi (Ξ), \Yup (⅄), \Zbar (Ƶ), \Zeta (Ζ).
\aa (å), \ac (∾), \accurrent (⏦), \acidfree (♾), \acwcirclearrow (⥀), \acwgapcirclearrow (⟲), \acwleftarcarrow (⤹), \acwopencirclearrow (↺), \acwoverarcarrow (⤺), \acwundercurvearrow (⤻), \adots (⋰), \ae (æ), \aleph (ℵ), \alpha (α), \amalg (⨿), \angdnr (⦟), \angle (∠), \angles (⦞), \angleubar (⦤), \approx (≈), \approxeq (≊), \approxeqq (⩰), \approxident (≋), \arceq (≘), \aries (♈), \assert (⊦), \ast (∗), \asteq (⩮), \astrosun (☉), \asymp (≍), \awint (⨑).
\bNot (⫭), \backcong (≌), \backdprime (‶), \backepsilon (϶), \backprime (‵), \backsim (∽), \backsimeq (⋍), \backslash (\), \backtrprime (‷), \bagmember (⋿), \barV (⫪), \barcap (⩃), \barcup (⩂), \bardownharpoonleft (⥡), \bardownharpoonright (⥝), \barleftarrow (⇤), \barleftarrowrightarrowbar (↹), \barleftharpoondown (⥖), \barleftharpoonup (⥒), \barovernorthwestarrow (↸), \barrightarrowdiamond (⤠), \barrightharpoondown (⥟), \barrightharpoonup (⥛), \baruparrow (⤒), \barupharpoonleft (⥘), \barupharpoonright (⥔), \barvee (⊽), \barwedge (⊼), \bbrktbrk (⎶), \bdHrule (═), \bdVrule (║), \bdbVbH (╬), \bdbVbh (╫), \bdbVlH (╣), \bdbVlh (╢), \bdbVrH (╠), \bdbVrh (╟), \bdbvbH (╪), \bdbvbh (┼), \bdbvlH (╡), \bdbvlh (┤), \bdbvrH (╞), \bdbvrh (├), \bddVbH (╦), \bddVbh (╥), \bddVlH (╗), \bddVlh (╖), \bddVrH (╔), \bddVrh (╓), \bddvbH (╤), \bddvbh (┬), \bddvlH (╕), \bddvlh (┐), \bddvrH (╒), \bddvrh (┌), \bdhrule (─), \bdnesw (╱), \bdnwse (╲), \bdquadhdash (┈), \bdquadvdash (┊), \bdtriplevdash (┆), \bduVbH (╩), \bduVbh (╨), \bduVlH (╝), \bduVlh (╜), \bduVrH (╚), \bduVrh (╙), \bduvbH (╧), \bduvbh (┴), \bduvlH (╛), \bduvlh (┘), \bduvrH (╘), \bduvrh (└), \bdvrule (│), \because (∵), \benzenr (⏣), \beta (β), \beth (ℶ), \between (≬), \bigblacktriangledown (▼), \bigblacktriangleup (▲), \bigbot (⟘), \bigcap (⋂), \bigcup (⋃), \bigslopedvee (⩗), \bigslopedwedge (⩘), \bigstar (★), \bigtop (⟙), \bigtriangledown (▽), \bigtriangleup (△), \bigvee (⋁), \bigwedge (⋀), \bigwhitestar (☆), \blackcircledownarrow (⧭), \blackcircledrightdot (⚈), \blackcircledsanseight (➑), \blackcircledsansfive (➎), \blackcircledsansfour (➍), \blackcircledsansnine (➒), \blackcircledsansone (➊), \blackcircledsansseven (➐), \blackcircledsanssix (➏), \blackcircledsansten (➓), \blackcircledsansthree (➌), \blackcircledsanstwo (➋), \blackcircledtwodots (⚉), \blackcircleulquadwhite (◕), \blackdiamonddownarrow (⧪), \blackhourglass (⧗), \blackinwhitediamond (◈), \blackinwhitesquare (▣), \blacklefthalfcircle (◖), \blackpointerleft (◄), \blackpointerright (►), \blackrighthalfcircle (◗), \blacksmiley (☻), \blacktriangle (▴), \blacktriangledown (▾), \blacktriangleleft (◀), \blacktriangleright (▶), \blkhorzoval (⬬), \blkvertoval (⬮), \blockfull (█), \blockhalfshaded (▒), \blocklefthalf (▌), \blocklowhalf (▄), \blockqtrshaded (░), \blockrighthalf (▐), \blockthreeqtrshaded (▓), \blockuphalf (▀), \bot (⊥), \botsemicircle (◡), \bowtie (⋈), \box (◻), \boxast (⧆), \boxbar (◫), \boxbox (⧈), \boxbslash (⧅), \boxcircle (⧇), \boxdiag (⧄), \boxdot (⊡), \boxminus (⊟), \boxonbox (⧉), \boxplus (⊞), \boxtimes (⊠), \bsimilarleftarrow (⭁), \bsimilarrightarrow (⭇), \bsolhsub (⟈), \btimes (⨲), \bullet (∙), \bullseye (◎), \bumpeq (≏), \bumpeqq (⪮).
\calB (ℬ), \calE (ℰ), \calF (ℱ), \calH (ℋ), \calM (ℳ), \calR (ℛ), \cap (∩), \capdot (⩀), \capwedge (⩄), \caretinsert (‸), \carreturn (⏎), \carriagereturn (↵), \ccwundercurvearrow (⤿), \cdot (⋅), \cdotp (·), \cdots (⋯), \cdprime (ʺ), \checkmark (✓), \chi (χ), \cirE (⧃), \cirbot (⟟), \circ (∘), \circeq (≗), \circfint (⨐), \circlebottomhalfblack (◒), \circledA (Ⓐ), \circledB (Ⓑ), \circledC (Ⓒ), \circledD (Ⓓ), \circledE (Ⓔ), \circledF (Ⓕ), \circledG (Ⓖ), \circledH (Ⓗ), \circledI (Ⓘ), \circledJ (Ⓙ), \circledK (Ⓚ), \circledL (Ⓛ), \circledM (Ⓜ), \circledN (Ⓝ), \circledO (Ⓞ), \circledP (Ⓟ), \circledQ (Ⓠ), \circledR (Ⓡ), \circledS (Ⓢ), \circledT (Ⓣ), \circledU (Ⓤ), \circledV (Ⓥ), \circledW (Ⓦ), \circledX (Ⓧ), \circledY (Ⓨ), \circledZ (Ⓩ), \circleda (ⓐ), \circledast (⊛), \circledb (ⓑ), \circledbullet (⦿), \circledc (ⓒ), \circledcirc (⊚), \circledd (ⓓ), \circleddash (⊝), \circlede (ⓔ), \circledeight (⑧), \circledequal (⊜), \circledf (ⓕ), \circledfive (⑤), \circledfour (④), \circledg (ⓖ), \circledh (ⓗ), \circledi (ⓘ), \circledj (ⓙ), \circledk (ⓚ), \circledl (ⓛ), \circledm (ⓜ), \circledn (ⓝ), \circlednine (⑨), \circledo (ⓞ), \circledone (①), \circledownarrow (⧬), \circledp (ⓟ), \circledparallel (⦷), \circledq (ⓠ), \circledr (ⓡ), \circledrightdot (⚆), \circleds (ⓢ), \circledsanseight (➇), \circledsansfive (➄), \circledsansfour (➃), \circledsansnine (➈), \circledsansone (➀), \circledsansseven (➆), \circledsanssix (➅), \circledsansten (➉), \circledsansthree (➂), \circledsanstwo (➁), \circledseven (⑦), \circledsix (⑥), \circledstar (✪), \circledt (ⓣ), \circledthree (③), \circledtwo (②), \circledtwodots (⚇), \circledu (ⓤ), \circledv (ⓥ), \circledvert (⦶), \circledw (ⓦ), \circledwhitebullet (⦾), \circledx (ⓧ), \circledy (ⓨ), \circledz (ⓩ), \circledzero (⓪), \circlehbar (⦵), \circlelefthalfblack (◐), \circlellquad (◵), \circlelrquad (◶), \circleonleftarrow (⬰), \circleonrightarrow (⇴), \circlerighthalfblack (◑), \circletophalfblack (◓), \circleulquad (◴), \circleurquad (◷), \circleurquadblack (◔), \circlevertfill (◍), \cirmid (⫯), \cirscir (⧂), \clangle (〈), \closedvarcap (⩍), \closedvarcup (⩌), \closedvarcupsmashprod (⩐), \closure (⁐), \cloverleaf (⌘), \clubsuit (♣), \colon (:), \colon (∶), \coloneq (≔), \commaminus (⨩), \complement (∁), \concavediamond (⟡), \concavediamondtickleft (⟢), \concavediamondtickright (⟣), \cong (≅), \congdot (⩭), \conictaper (⌲), \conjunction (☌), \coprod (∐), \cprime (ʹ), \crangle (〉), \csub (⫏), \csube (⫑), \csup (⫐), \csupe (⫒), \cuberoot (∛), \cup (∪), \cupdot (⊍), \cupleftarrow (⊌), \cupvee (⩅), \curlyeqprec (⋞), \curlyeqsucc (⋟), \curlyvee (⋎), \curlywedge (⋏), \curvearrowleft (↶), \curvearrowleftplus (⤽), \curvearrowright (↷), \curvearrowrightminus (⤼), \cwcirclearrow (⥁), \cwgapcirclearrow (⟳), \cwopencirclearrow (↻), \cwrightarcarrow (⤸), \cwundercurvearrow (⤾), \cylcty (⌭).
\dag (†), \dagger (†), \daleth (ℸ), \danger (☡), \dashV (⫣), \dashVdash (⟛), \dashcolon (∹), \dashleftharpoondown (⥫), \dashrightharpoondown (⥭), \dashv (⊣), \dbkarow (⤏), \ddag (‡), \ddagger (‡), \ddots (⋱), \ddotseq (⩷), \delta (δ), \dh (ð), \diameter (⌀), \diamond (◇), \diamondbotblack (⬙), \diamondcdot (⟐), \diamondleftarrow (⤝), \diamondleftarrowbar (⤟), \diamondleftblack (⬖), \diamondrightblack (⬗), \diamondsuit (♢), \diamondtopblack (⬘), \dicei (⚀), \diceii (⚁), \diceiii (⚂), \diceiv (⚃), \dicev (⚄), \dicevi (⚅), \digamma (ϝ), \dingasterisk (✽), \dircurrent (⎓), \disin (⋲), \div (÷), \divideontimes (⋇), \dj (đ), \dlcrop (⌍), \doteq (≐), \dotequiv (⩧), \dotminus (∸), \dotplus (∔), \dots (…), \dotsim (⩪), \dotsminusdots (∺), \dottedcircle (◌), \dottedsquare (⬚), \dottimes (⨰), \doublebarvee (⩢), \doublebarwedge (⩞), \doubleplus (⧺), \downarrow (↓), \downarrowbar (⤓), \downarrowbarred (⤈), \downdasharrow (⇣), \downdownarrows (⇊), \downfishtail (⥿), \downharpoonleft (⇃), \downharpoonleftbar (⥙), \downharpoonright (⇂), \downharpoonrightbar (⥕), \downharpoonsleftright (⥥), \downrightcurvedarrow (⤵), \downtriangleleftblack (⧨), \downtrianglerightblack (⧩), \downuparrows (⇵), \downupharpoonsleftright (⥯), \downwhitearrow (⇩), \downzigzagarrow (↯), \dprime (″), \draftingarrow (➛), \drbkarow (⤐), \drcrop (⌌), \dsol (⧶), \dsub (⩤), \dualmap (⧟).
\earth (♁), \egsdot (⪘), \eighthnote (♪), \elinters (⏧), \ell (ℓ), \elsdot (⪗), \emdash (—), \emptyset (∅), \emptysetoarr (⦳), \emptysetoarrl (⦴), \emptysetobar (⦱), \emptysetocirc (⦲), \endash (–), \enleadertwodots (‥), \envelope (✉), \eparsl (⧣), \epsilon (ϵ), \eqcirc (≖), \eqcolon (≕), \eqdef (≝), \eqdot (⩦), \eqeq (⩵), \eqeqeq (⩶), \eqgtr (⋝), \eqless (⋜), \eqqgtr (⪚), \eqqless (⪙), \eqqplus (⩱), \eqqsim (⩳), \eqqslantgtr (⪜), \eqqslantless (⪛), \eqsim (≂), \eqslantgtr (⪖), \eqslantless (⪕), \equalleftarrow (⭀), \equalparallel (⋕), \equalrightarrow (⥱), \equiv (≡), \equivDD (⩸), \equivVert (⩨), \equivVvert (⩩), \eqvparsl (⧥), \errbarblackcircle (⧳), \errbarblackdiamond (⧱), \errbarblacksquare (⧯), \errbarcircle (⧲), \errbardiamond (⧰), \errbarsquare (⧮), \eta (η), \euro (€), \exists (∃).
\fallingdotseq (≒), \fbowtie (⧓), \fcmp (⨾), \fdiagovnearrow (⤯), \fdiagovrdiag (⤬), \female (♀), \figdash (‒), \fint (⨏), \fisheye (◉), \flat (♭), \fltns (⏥), \forall (∀), \forks (⫝̸), \forksnot (⫝), \forkv (⫙), \fourthroot (∜), \fourvdots (⦙), \fracfiveeighths (⅝), \fracfivesixths (⅚), \fracfourfifths (⅘), \fraconeeighth (⅛), \fraconefifth (⅕), \fraconesixth (⅙), \fraconethird (⅓), \fracseveneights (⅞), \fracslash (⁄), \fracthreeeighths (⅜), \fracthreefifths (⅗), \fractwofifths (⅖), \fractwothirds (⅔), \frakC (ℭ), \frakH (ℌ), \frakZ (ℨ), \frown (⌢), \frownie (☹), \fullouterjoin (⟗).
\gamma (γ), \ge (≥), \geq (≥), \geqq (≧), \geqslant (⩾), \gescc (⪩), \gesdot (⪀), \gesdoto (⪂), \gesdotol (⪄), \gesles (⪔), \gets (←), \gg (≫), \ggg (⋙), \gggnest (⫸), \gimel (ℷ), \glE (⪒), \gla (⪥), \gleichstark (⧦), \glj (⪤), \gnapprox (⪊), \gneq (⪈), \gneqq (≩), \gnsim (⋧), \greater (>), \gsime (⪎), \gsiml (⪐), \gtcc (⪧), \gtcir (⩺), \gtlpar (⦠), \gtquest (⩼), \gtrapprox (⪆), \gtrarr (⥸), \gtrdot (⋗), \gtreqless (⋛), \gtreqqless (⪌), \gtrless (≷), \gtrsim (≳), \guillemotleft («), \guillemotright (»), \guilsinglleft (‹), \guilsinglright (›).
\harrowextender (⎯), \hatapprox (⩯), \hbar (ℏ), \heartsuit (♡), \hermitmatrix (⊹), \hexagon (⎔), \hexagonblack (⬣), \hiraganano (の), \hknearrow (⤤), \hknwarrow (⤣), \hksearow (⤥), \hkswarow (⤦), \hookleftarrow (↩), \hookrightarrow (↪), \horizbar (―), \hourglass (⧖), \house (⌂), \hrectangle (▭), \hrectangleblack (▬), \hslash (ℏ), \hyphenbullet (⁃), \hzigzag (〰).
\iiiint (⨌), \iiint (∭), \iinfin (⧜), \iint (∬), \imageof (⊷), \in (∈), \incare (℅), \increment (∆), \infty (∞), \int (∫), \intBar (⨎), \intbar (⨍), \intbottom (⌡), \intcap (⨙), \intclockwise (∱), \intcup (⨚), \intercal (⊺), \interleave (⫴), \intextender (⎮), \intlharhk (⨗), \intprod (⨼), \intprodr (⨽), \inttop (⌠), \intx (⨘), \inversebullet (◘), \inversewhitecircle (◙), \invnot (⌐), \invwhitelowerhalfcircle (◛), \invwhiteupperhalfcircle (◚), \iota (ι), \ipasupgamma (ˠ), \ipasupl (ˡ), \ipasuprerglotstpp (ˤ), \ipasups (ˢ), \ipasupx (ˣ), \ipaunaspirated (˭), \ipavoicing (ˬ), \isinE (⋹), \isindot (⋵), \isinobar (⋷), \isins (⋴), \isinvb (⋸), \itBbbD (ⅅ), \itBbbd (ⅆ), \itBbbe (ⅇ), \itBbbi (ⅈ), \itBbbj (ⅉ).
\jupiter (♃), \kappa (κ), \kernelcontraction (∻), \koppa (ϟ).
\l (ł), \lAngle (⟪), \lBrace (⦃), \lBrack (⟦), \lParen (⦅), \lambda (λ), \lambdabar (ƛ), \langle (⟨), \langledot (⦑), \laplac (⧠), \lasp (ʽ), \lat (⪫), \late (⪭), \lbag (⟅), \lblkbrbrak (⦗), \lbrace ({), \lbracelend (⎩), \lbracemid (⎨), \lbraceuend (⎧), \lbrack ([), \lbrackextender (⎢), \lbracklend (⎣), \lbracklltick (⦏), \lbrackubar (⦋), \lbrackuend (⎡), \lbrackultick (⦍), \lbrbrak (❲), \lceil (⌈), \lcurvyangle (⧼), \ldasharrhead (⇠), \le (≤), \leadsto (↝), \leftarrow (←), \leftarrowapprox (⭊), \leftarrowbackapprox (⭂), \leftarrowbsimilar (⭋), \leftarrowless (⥷), \leftarrowonoplus (⬲), \leftarrowplus (⥆), \leftarrowshortrightarrow (⥃), \leftarrowsimilar (⥳), \leftarrowsubset (⥺), \leftarrowtail (↢), \leftarrowtriangle (⇽), \leftarrowx (⬾), \leftbkarrow (⤌), \leftcurvedarrow (⬿), \leftdasharrow (⇠), \leftdasharrowhead (⇡), \leftdbkarrow (⤎), \leftdbltail (⤛), \leftdotarrow (⬸), \leftdowncurvedarrow (⤶), \leftfishtail (⥼), \leftharpoondown (↽), \leftharpoondownbar (⥞), \leftharpoonsupdown (⥢), \leftharpoonup (↼), \leftharpoonupbar (⥚), \leftharpoonupdash (⥪), \leftleftarrows (⇇), \leftmoon (☾), \leftouterjoin (⟕), \leftrightarrow (↔), \leftrightarrowcircle (⥈), \leftrightarrows (⇆), \leftrightarrowtriangle (⇿), \leftrightharpoondowndown (⥐), \leftrightharpoondownup (⥋), \leftrightharpoons (⇋), \leftrightharpoonsdown (⥧), \leftrightharpoonsup (⥦), \leftrightharpoonupdown (⥊), \leftrightharpoonupup (⥎), \leftrightsquigarrow (↭), \leftsquigarrow (↜), \leftsquigarrow (⇜), \lefttail (⤙), \leftthreearrows (⬱), \leftthreetimes (⋋), \leftwhitearrow (⇦), \leq (≤), \leqq (≦), \leqqslant (⫹), \leqqslant (⫺), \leqslant (⩽), \lescc (⪨), \lesdot (⩿), \lesdoto (⪁), \lesdotor (⪃), \lesges (⪓), \less (<), \lessapprox (⪅), \lessdot (⋖), \lesseqgtr (⋚), \lesseqqgtr (⪋), \lessgtr (≶), \lesssim (≲), \lfbowtie (⧑), \lfloor (⌊), \lftimes (⧔), \lgE (⪑), \lgblkcircle (⬤), \lgblksquare (⬛), \lgwhtcircle (◯), \lgwhtsquare (⬜), \lhd (⊲), \linefeed (↴), \ll (≪), \llangle (⦉), \llarc (◟), \llblacktriangle (◣), \llcorner (⌞), \lll (⋘), \lllnest (⫷), \llparenthesis (⦇), \lltriangle (◺), \lmoustache (⎰), \lnapprox (⪉), \lneq (⪇), \lneqq (≨), \lnsim (⋦), \longdashv (⟞), \longdivision (⟌), \longleftarrow (⟵), \longleftrightarrow (⟷), \longleftsquigarrow (⬳), \longmapsfrom (⟻), \longmapsto (⟼), \longrightarrow (⟶), \longrightsquigarrow (⟿), \looparrowleft (↫), \looparrowright (↬), \lowint (⨜), \lozenge (◊), \lozengeminus (⟠), \lparenextender (⎜), \lparenlend (⎝), \lparenless (⦓), \lparenuend (⎛), \lq (‘), \lrarc (◞), \lrblacktriangle (◢), \lrcorner (⌟), \lrtriangle (◿), \lrtriangleeq (⧡), \lsime (⪍), \lsimg (⪏), \lsqhook (⫍), \ltcc (⪦), \ltcir (⩹), \ltimes (⋉), \ltlarr (⥶), \ltquest (⩻), \ltrivb (⧏), \lvboxline (⎸), \lvzigzag (⧘).
\male (♂), \maltese (✠), \mapsdown (↧), \mapsfrom (↤), \mapsto (↦), \mapsup (↥), \mdblkdiamond (⬥), \mdblklozenge (⬧), \mdblkrcl (⚫), \mdblksquare (◼), \mdlgblkcircle (●), \mdlgblkdiamond (◆), \mdlgblklozenge (⧫), \mdlgblksquare (■), \mdlgwhtcircle (○), \mdlgwhtdiamond (◇), \mdlgwhtsquare (□), \mdsmblkcircle (⦁), \mdsmblksquare (◾), \mdsmwhtcircl (⚬), \mdsmwhtsquare (◽), \mdwhtcircl (⚪), \mdwhtdiamond (⬦), \mdwhtlozenge (⬨), \mdwhtsquare (◻), \measangledltosw (⦯), \measangledrtose (⦮), \measangleldtosw (⦫), \measanglelutonw (⦩), \measanglerdtose (⦪), \measanglerutone (⦨), \measangleultonw (⦭), \measangleurtone (⦬), \measeq (≞), \measuredangle (∡), \measuredangleleft (⦛), \measuredrightangle (⊾), \medblackstar (⭑), \medmathspace ( ), \medwhitestar (⭐), \mercury (☿), \mho (℧), \mid (∣), \midbarvee (⩝), \midbarwedge (⩜), \midcir (⫰), \minus (−), \minusdot (⨪), \minusfdots (⨫), \minusrdots (⨬), \mlcp (⫛), \models (⊧), \mp (∓), \mu (μ), \multimap (⊸), \multimapinv (⟜).
\nHdownarrow (⇟), \nHuparrow (⇞), \nLeftarrow (⇍), \nLeftrightarrow (⇎), \nRightarrow (⇏), \nVDash (⊯), \nVdash (⊮), \nVleftarrow (⇺), \nVleftarrowtail (⬺), \nVleftrightarrow (⇼), \nVrightarrow (⇻), \nVrightarrowtail (⤕), \nVtwoheadleftarrow (⬵), \nVtwoheadleftarrowtail (⬽), \nVtwoheadrightarrow (⤁), \nVtwoheadrightarrowtail (⤘), \nabla (∇), \napprox (≉), \nasymp (≭), \natural (♮), \ncong (≇), \ne (≠), \nearrow (↗), \neg (¬), \neovnwarrow (⤱), \neovsearrow (⤮), \neptune (♆), \neq (≠), \nequiv (≢), \neswarrow (⤢), \neuter (⚲), \nexists (∄), \ng (ŋ), \ngeq (≱), \ngtr (≯), \ngtrless (≹), \ngtrsim (≵), \nhVvert (⫵), \nhpar (⫲), \ni (∋), \niobar (⋾), \nis (⋼), \nisd (⋺), \nleftarrow (↚), \nleftrightarrow (↮), \nleq (≰), \nless (≮), \nlessgtr (≸), \nlesssim (≴), \nmid (∤), \nni (∌), \nobreakhyphen (‑), \notin (∉), \nparallel (∦), \npolint (⨔), \nprec (⊀), \npreccurlyeq (⋠), \nrightarrow (↛), \nsim (≁), \nsime (≄), \nsqsubseteq (⋢), \nsqsupseteq (⋣), \nsubset (⊄), \nsubseteq (⊈), \nsucc (⊁), \nsucccurlyeq (⋡), \nsupset (⊅), \nsupseteq (⊉), \ntriangleleft (⋪), \ntrianglelefteq (⋬), \ntriangleright (⋫), \ntrianglerighteq (⋭), \nu (ν), \nvDash (⊭), \nvLeftarrow (⤂), \nvLeftrightarrow (⤄), \nvRightarrow (⤃), \nvdash (⊬), \nvinfty (⧞), \nvleftarrow (⇷), \nvleftarrowtail (⬹), \nvleftrightarrow (⇹), \nvrightarrow (⇸), \nvrightarrowtail (⤔), \nvtwoheadleftarrow (⬴), \nvtwoheadleftarrowtail (⬼), \nvtwoheadrightarrow (⤀), \nvtwoheadrightarrowtail (⤗), \nwarrow (↖), \nwovnearrow (⤲), \nwsearrow (⤡).
\o (ø), \obar (⌽), \obot (⦺), \obrbrak (⏠), \obslash (⦸), \odiv (⨸), \odot (⊙), \odotslashdot (⦼), \oe (œ), \ogreaterthan (⧁), \ohorn (ơ), \oiiint (∰), \oiint (∯), \oint (∮), \ointctrclockwise (∳), \olcross (⦻), \oldKoppa (Ϙ), \oldkoppa (ϙ), \olessthan (⧀), \omega (ω), \omicron (ο), \ominus (⊖), \operp (⦹), \oplus (⊕), \opluslhrim (⨭), \oplusrhrim (⨮), \origof (⊶), \oslash (⊘), \otimes (⊗), \otimeshat (⨶), \otimeslhrim (⨴), \otimesrhrim (⨵), \overbrace (⏞), \overbracket (⎴), \overline (‾), \overparen (⏜), \owns (∋).
\parallel (∥), \parallelogram (▱), \parallelogramblack (▰), \parsim (⫳), \partial (∂), \partialmeetcontraction (⪣), \pentagon (⬠), \pentagonblack (⬟), \perp (⟂), \perps (⫡), \phi (ϕ), \phone (☎), \pi (π), \pitchfork (⋔), \plusdot (⨥), \pluseqq (⩲), \plushat (⨣), \plussim (⨦), \plussubtwo (⨧), \plustrif (⨨), \pluto (♇), \pm (±), \pointnt (⨕), \postalmark (〒), \prec (≺), \precapprox (⪷), \preccurlyeq (≼), \preceq (⪯), \preceqq (⪳), \precnapprox (⪹), \precneq (⪱), \precneqq (⪵), \precnsim (⋨), \precsim (≾), \prime (′), \prod (∏), \profalar (⌮), \profline (⌒), \profsurf (⌓), \propto (∝), \prurel (⊰), \psi (ψ), \pullback (⟓), \pushout (⟔).
\qprime (⁗), \quarternote (♩), \questeq (≟), \quotdblbase („), \quotdblright (‟), \quotsinglbase (‚), \quotsinglright (‛).
\rAngle (⟫), \rBrace (⦄), \rBrack (⟧), \rParen (⦆), \rangle (⟩), \rangledot (⦒), \rangledownzigzagarrow (⍼), \rasp (ʼ), \rbag (⟆), \rblkbrbrak (⦘), \rbrace (}), \rbracelend (⎭), \rbracemid (⎬), \rbraceuend (⎫), \rbrack (]), \rbrackextender (⎥), \rbracklend (⎦), \rbracklrtick (⦎), \rbrackubar (⦌), \rbrackuend (⎤), \rbrackurtick (⦐), \rbrbrak (❳), \rceil (⌉), \rcurvyangle (⧽), \rdiagovfdiag (⤫), \rdiagovsearrow (⤰), \recorder (⌕), \revangle (⦣), \revangleubar (⦥), \revemptyset (⦰), \revnmid (⫮), \rfbowtie (⧒), \rfloor (⌋), \rftimes (⧕), \rhd (⊳), \rho (ρ), \righarrowbsimilar (⭌), \rightangle (∟), \rightanglemdot (⦝), \rightanglesqr (⦜), \rightarrow (→), \rightarrowapprox (⥵), \rightarrowbackapprox (⭈), \rightarrowbar (⇥), \rightarrowdiamond (⤞), \rightarrowgtr (⭃), \rightarrowonoplus (⟴), \rightarrowplus (⥅), \rightarrowshortleftarrow (⥂), \rightarrowsimilar (⥴), \rightarrowsupset (⭄), \rightarrowtail (↣), \rightarrowtriangle (⇾), \rightarrowx (⥇), \rightbkarrow (⤍), \rightcurvedarrow (⤳), \rightdasharrow (⇢), \rightdbltail (⤜), \rightdotarrow (⤑), \rightdowncurvedarrow (⤷), \rightfishtail (⥽), \rightharpoondown (⇁), \rightharpoondownbar (⥗), \rightharpoonsupdown (⥤), \rightharpoonup (⇀), \rightharpoonupbar (⥓), \rightharpoonupdash (⥬), \rightimply (⥰), \rightleftarrows (⇄), \rightleftharpoons (⇌), \rightleftharpoonsdown (⥩), \rightleftharpoonsup (⥨), \rightmoon (☽), \rightouterjoin (⟖), \rightpentagon (⭔), \rightpentagonblack (⭓), \rightrightarrows (⇉), \rightsquigarrow (↝), \rightsquigarrow (⇝), \righttail (⤚), \rightthreearrows (⇶), \rightthreetimes (⋌), \rightwhitearrow (⇨), \ringplus (⨢), \risingdotseq (≓), \rmoustache (⎱), \rparenextender (⎟), \rparengtr (⦔), \rparenlend (⎠), \rparenuend (⎞), \rppolint (⨒), \rq (’), \rrangle (⦊), \rrparenthesis (⦈), \rsolbar (⧷), \rsqhook (⫎), \rsub (⩥), \rtimes (⋊), \rtriltri (⧎), \ruledelayed (⧴), \rvboxline (⎹), \rvzigzag (⧙).
\sampi (ϡ), \sansLmirrored (⅃), \sansLturned (⅂), \saturn (♄), \scissors (✂), \scpolint (⨓), \scrB (ℬ), \scrE (ℰ), \scrF (ℱ), \scrH (ℋ), \scrI (ℐ), \scrL (ℒ), \scrM (ℳ), \scrR (ℛ), \scre (ℯ), \scrg (ℊ), \scro (ℴ), \scurel (⊱), \searrow (↘), \seovnearrow (⤭), \setminus (∖), \setminus (⧵), \sharp (♯), \shortdowntack (⫟), \shortleftarrow (←), \shortlefttack (⫞), \shortrightarrow (→), \shortrightarrowleftarrow (⥄), \shortuptack (⫠), \shuffle (⧢), \sigma (σ), \silon (υ), \silon (ϒ), \sim (∼), \simeq (≃), \simgE (⪠), \simgtr (⪞), \similarleftarrow (⭉), \similarrightarrow (⥲), \simlE (⪟), \simless (⪝), \simminussim (⩬), \simneqq (≆), \simplus (⨤), \simrdots (⩫), \sinewave (∿), \slash (∕), \smallblacktriangleleft (◂), \smallblacktriangleright (▸), \smalldiamond (⋄), \smallin (∊), \smallint (∫), \smallni (∍), \smallsetminus (∖), \smalltriangleleft (◃), \smalltriangleright (▹), \smashtimes (⨳), \smblkdiamond (⬩), \smblklozenge (⬪), \smblksquare (▪), \smeparsl (⧤), \smile (⌣), \smiley (☺), \smt (⪪), \smte (⪬), \smwhitestar (⭒), \smwhtcircle (◦), \smwhtlozenge (⬫), \smwhtsquare (▫), \spadesuit (♠), \sphericalangle (∢), \sphericalangleup (⦡), \sqcap (⊓), \sqcup (⊔), \sqint (⨖), \sqlozenge (⌑), \sqrt (√), \sqrt3 (∛), \sqrt4 (∜), \sqrtbottom (⎷), \sqsubset (⊏), \sqsubseteq (⊑), \sqsubsetneq (⋤), \sqsupset (⊐), \sqsupseteq (⊒), \sqsupsetneq (⋥), \squarecrossfill (▩), \squaregrayfill (▩), \squarehfill (▤), \squarehvfill (▦), \squareleftblack (◧), \squareleftblack (◨), \squarellblack (⬕), \squarellquad (◱), \squarelrblack (◪), \squarelrquad (◲), \squareneswfill (▨), \squarenwsefill (▧), \squareulblack (◩), \squareulquad (◰), \squareurblack (⬔), \squareurquad (◳), \squarevfill (▥), \squoval (▢), \ss (ß), \star (⋆), \stareq (≛), \sterling (£), \stigma (ϛ), \strns (⏤), \subedot (⫃), \submult (⫁), \subrarr (⥹), \subset (⊂), \subsetapprox (⫉), \subsetcirc (⟃), \subsetdot (⪽), \subseteq (⊆), \subseteqq (⫅), \subsetneq (⊊), \subsetneqq (⫋), \subsetplus (⪿), \subsim (⫇), \subsub (⫕), \subsup (⫓), \succ (≻), \succapprox (⪸), \succcurlyeq (≽), \succeq (⪰), \succeqq (⪴), \succnapprox (⪺), \succneq (⪲), \succneqq (⪶), \succnsim (⋩), \succsim (≿), \sum (∑), \sumbottom (⎳), \sumint (⨋), \sumtop (⎲), \sun (☼), \supdsub (⫘), \supedot (⫄), \suphsol (⟉), \suphsub (⫗), \suplarr (⥻), \supmult (⫂), \supn (ⁿ), \supset (⊃), \supsetapprox (⫊), \supsetcirc (⟄), \supsetdot (⪾), \supseteq (⊇), \supseteqq (⫆), \supsetneq (⊋), \supsetneqq (⫌), \supsetplus (⫀), \supsim (⫈), \supsub (⫔), \supsup (⫖), \surd (√), \swarrow (↙).
\talloblong (⫾), \target (⌖), \tau (τ), \taurus (♉), \testhookx (ᶍ), \textAsterisks (⁑), \textacute (ˊ), \textadvanced (˖), \textain (ʿ), \textasciiacute (´), \textasciicircum (^), \textasciidieresis (¨), \textasciigrave (‘), \textasciimacron (¯), \textasciitilde (~), \textasterisklow (⁎), \textbackdprime (‶), \textbackprime (‵), \textbacktrprime (‷), \textbardotlessj (ɟ), \textbardotlessjvar (ʄ), \textbarglotstop (ʡ), \textbari (ɨ), \textbarl (ƚ), \textbaro (ɵ), \textbarrevglotstop (ʢ), \textbaru (ʉ), \textbeltl (ɬ), \textbenttailyogh (ƺ), \textbreve (˘), \textbrokenbar (¦), \textbullet (•), \textbullseye (ʘ), \textcent (¢), \textcircledP (℗), \textcloseepsilon (ʚ), \textcloseomega (ɷ), \textcloserevepsilon (ɞ), \textcopyright (©), \textcrb (ƀ), \textcrh (ħ), \textcrinvglotstop (ƾ), \textcrlambda (ƛ), \textcrtwo (ƻ), \textctc (ɕ), \textctd (ȡ), \textctesh (ʆ), \textctj (ʝ), \textctl (ȴ), \textctn (ȵ), \textctt (ȶ), \textctyogh (ʓ), \textctz (ʑ), \textcurrency (¤), \textdctzlig (ʥ), \textdegree (°), \textdiscount (⁒), \textdollar ($), \textdotaccent (˙), \textdotlessj (ȷ), \textdoubleacute (˝), \textdoublebarpipe (ǂ), \textdoublepipe (ǁ), \textdprime (″), \textdptr (˅), \textdyoghlig (ʤ), \textdzlig (ʣ), \textepsilon (ɛ), \textesh (ʃ), \textestimated (℮), \textexclam (ǃ), \textexclamdown (¡), \textfishhookr (ɾ), \textflorin (ƒ), \textfranc (₣), \textgamma (ɣ), \textglotstop (ʔ), \textgrave (ˋ), \texthalflength (ˑ), \texthamza (ʾ), \texthen (ꜧ), \textheng (ꜧ), \texthooks (ᶊ), \texthookz (ᶎ), \texthtb (ɓ), \texthtc (ƈ), \texthtd (ɗ), \texthtg (ɠ), \texthth (ɦ), \texththeng (ɧ), \texthtk (ƙ), \texthtp (ƥ), \texthtq (ʠ), \texthtscg (ʛ), \texthtt (ƭ), \texthvlig (ƕ), \texthyphen (‐), \textinvglotstop (ʖ), \textinvscr (ʁ), \textiota (ɩ), \textlengthmark (ː), \textlhalfring (˓), \textlhookd (ᶁ), \textlhookk (ᶄ), \textlhookl (ᶅ), \textlhookt (ƫ), \textlhti (ɿ), \textlira (₤), \textlonglegr (ɼ), \textlongy (ʮ), \textlongy (ʯ), \textlooptoprevesh (ƪ), \textlowacute (ˏ), \textlowered (˕), \textlowgrave (ˎ), \textlowmacron (ˍ), \textlptr (˂), \textltailm (ɱ), \textltailn (ɲ), \textltilde (ɫ), \textlyoghlig (ɮ), \textmacron (ˉ), \textmu (µ), \textnumero (№), \textogonek (˛), \textohm (Ω), \textonehalf (½), \textonequarter (¼), \textonesuperior (¹), \textopeno (ɔ), \textordfeminine (ª), \textordmasculine (º), \textovercross (˟), \textoz (℥), \textpertenthousand (‱), \textperthousand (‰), \textpesetas (₧), \textphi (ɸ), \textpipe (ǀ), \textprime (′), \textprimstress (ˈ), \textqprime (⁗), \textquestiondown (¿), \textquotedbl ("), \textquotedblleft (“), \textquotedblright (”), \textraised (˔), \textraiseglotstop (ˀ), \textraiserevglotstop (ˁ), \textramshorns (ɤ), \textrecipe (℞), \textreferencemark (※), \textregistered (®), \textretracted (˗), \textreve (ɘ), \textrevepsilon (ɜ), \textrevglotstop (ʕ), \textrhalfring (˒), \textrhookrevepsilon (ɝ), \textrhookschwa (ɚ), \textrhoticity (˞), \textringaccent (˚), \textrptr (˃), \textrtaild (ɖ), \textrtaill (ɭ), \textrtailn (ɳ), \textrtailr (ɽ), \textrtails (ʂ), \textrtailt (ʈ), \textrtailz (ʐ), \textsca (ᴀ), \textscb (ʙ), \textsce (ᴇ), \textscg (ɢ), \textsch (ʜ), \textschwa (ə), \textsci (ɪ), \textscl (ʟ), \textscn (ɴ), \textscoelig (ɶ), \textscr (ʀ), \textscripta (ɑ), \textscriptg (ɡ), \textscriptv (ʋ), \textscu (ᴜ), \textscy (ʏ), \textsecstress (ˌ), \textsemicolonreversed (⁏), \textsilon (Υ), \textsmalltilde (˜), \textstretchcvar (ʗ), \textsubw (w), \textsuph (ʰ), \textsuphth (ʱ), \textsupinvscr (ʶ), \textsupj (ʲ), \textsupr (ʳ), \textsupturnr (ʴ), \textsupturnrrtail (ʵ), \textsupw (ʷ), \textsupy (ʸ), \texttctctlig (ʧ), \texttctctlig (ʨ), \textthreequarters (¾), \textthreesuperior (³), \texttrademark (™), \texttrprime (‴), \texttslig (ʦ), \textturna (ɐ), \textturncomma (ʻ), \textturnh (ɥ), \textturnk (ʞ), \textturnlonglegr (ɺ), \textturnm (ɯ), \textturnmrleg (ɰ), \textturnr (ɹ), \textturnrrtail (ɻ), \textturnscripta (ɒ), \textturnt (ʇ), \textturnv (ʌ), \textturnw (ʍ), \textturny (ʎ), \texttwosuperior (²), \textupsilon (ʊ), \textuptr (˄), \textvibyi (ʅ), \textvisiblespace (␣), \textyogh (ʒ), \th (þ), \therefore (∴), \thermod (⧧), \theta (θ), \thickapprox (≈), \thicksim (∼), \threedangle (⟀), \threedotcolon (⫶), \tieconcat (⁀), \tieinfty (⧝), \times (×), \timesbar (⨱), \tminus (⧿), \to (→), \toea (⤨), \tona (⤧), \tonebarextrahigh (˥), \tonebarextralow (˩), \tonebarhigh (˦), \tonebarlow (˨), \tonebarmid (˧), \top (⊤), \topbot (⌶), \topcir (⫱), \topfork (⫚), \topsemicircle (◠), \tosa (⤩), \towa (⤪), \tplus (⧾), \trapezium (⏢), \trianglecdot (◬), \triangledown (▿), \triangleexclam (⚠), \triangleleft (◁), \triangleleftblack (◭), \trianglelefteq (⊴), \triangleminus (⨺), \triangleodot (⧊), \triangleplus (⨹), \triangleq (≜), \triangleright (▷), \trianglerightblack (◮), \trianglerighteq (⊵), \triangles (⧌), \triangleserifs (⧍), \triangletimes (⨻), \triangleubar (⧋), \tripleplus (⧻), \trprime (‴), \turnangle (⦢), \turnediota (℩), \turnednot (⌙), \twocaps (⩋), \twocups (⩊), \twoheaddownarrow (↡), \twoheadleftarrow (↞), \twoheadleftarrowtail (⬻), \twoheadleftdbkarrow (⬷), \twoheadmapsfrom (⬶), \twoheadmapsto (⤅), \twoheadrightarrow (↠), \twoheadrightarrowtail (⤖), \twoheaduparrow (↟), \twoheaduparrowcircle (⥉), \twolowline (‗), \twonotes (♫), \typecolon (⦂).
\ubrbrak (⏡), \uhorn (ư), \ularc (◜), \ulblacktriangle (◤), \ulcorner (⌜), \ulcrop (⌏), \ultriangle (◸), \uminus (⩁), \underbrace (⏟), \underbracket (⎵), \underparen (⏝), \unlhd (⊴), \unrhd (⊵), \upand (⅋), \uparrow (↑), \uparrowbarred (⤉), \uparrowoncircle (⦽), \updasharrow (⇢), \updownarrow (↕), \updownarrowbar (↨), \updownarrows (⇅), \updownharpoonleftleft (⥑), \updownharpoonleftright (⥍), \updownharpoonrightleft (⥌), \updownharpoonrightright (⥏), \updownharpoonsleftright (⥮), \upfishtail (⥾), \upharpoonleft (↿), \upharpoonleftbar (⥠), \upharpoonright (↾), \upharpoonrightbar (⥜), \upharpoonsleftright (⥣), \upin (⟒), \upint (⨛), \uplus (⊎), \uprightcurvearrow (⤴), \upuparrows (⇈), \upwhitearrow (⇧), \urarc (◝), \urblacktriangle (◥), \urcorner (⌝), \urcrop (⌎), \urtriangle (◹).
\v (ˇ), \vBar (⫨), \vBarv (⫩), \vDash (⊨), \vDdash (⫢), \varTheta (ϴ), \varVdash (⫦), \varbarwedge (⌅), \varbeta (ϐ), \varclubsuit (♧), \vardiamondsuit (♦), \vardoublebarwedge (⌆), \varepsilon (ε), \varheartsuit (♥), \varhexagon (⬡), \varhexagonblack (⬢), \varhexagonlrbonds (⌬), \varin (∈), \varisinobar (⋶), \varisins (⋳), \varkappa (ϰ), \varlrtriangle (⊿), \varni (∋), \varniobar (⋽), \varnis (⋻), \varnothing (∅), \varointclockwise (∲), \varphi (φ), \varpi (ϖ), \varpropto (∝), \varrho (ϱ), \varrowextender (⏐), \varsigma (ς), \varspadesuit (♤), \varstar (✶), \vartheta (ϑ), \vartriangle (▵), \vartriangleleft (⊲), \vartriangleright (⊳), \varveebar (⩡), \vbraceextender (⎪), \vbrtri (⧐), \vdash (⊢), \vdots (⋮), \vectimes (⨯), \vee (∨), \veebar (⊻), \veedot (⟇), \veedoublebar (⩣), \veeeq (≚), \veemidvert (⩛), \veeodot (⩒), \veeonvee (⩖), \veeonwedge (⩙), \vert (|), \viewdata (⌗), \vlongdash (⟝), \vrectangle (▯), \vrectangleblack (▮), \vysmlblksquare (⬝), \vysmlwhtsquare (⬞), \vzigzag (⦚).
\watchicon (⌚), \wedge (∧), \wedgebar (⩟), \wedgedot (⟑), \wedgedoublebar (⩠), \wedgemidvert (⩚), \wedgeodot (⩑), \wedgeonwedge (⩕), \wedgeq (≙), \whitearrowupfrombar (⇪), \whiteinwhitetriangle (⟁), \whitepointerleft (◅), \whitepointerright (▻), \whitesquaretickleft (⟤), \whitesquaretickright (⟥), \whthorzoval (⬭), \whtvertoval (⬯), \wideangledown (⦦), \wideangleup (⦧), \wp (℘), \wr (≀).
\xbsol (⧹), \xi (ξ), \xsol (⧸), \yen (¥), \zeta (ζ), \zpipe (⨠),
IF ANYBODY WILL CHECK WHETHER ALL NAMES CORRESPOND TO RIGHT TEX SYMBOLS I SHALL APPRECIATE IT GREATLY.
Next: Index, Previous: TeX-like symbols, Up: Top [Contents][Index]
Appendix E GNU Free Documentation License
Copyright © 2000,2001,2002 Free Software Foundation, Inc. 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.
- PREAMBLE
The purpose of this License is to make a manual, textbook, or other functional and useful document free in the sense of freedom: to assure everyone the effective freedom to copy and redistribute it, with or without modifying it, either commercially or noncommercially. Secondarily, this License preserves for the author and publisher a way to get credit for their work, while not being considered responsible for modifications made by others.
This License is a kind of “copyleft”, which means that derivative works of the document must themselves be free in the same sense. It complements the GNU General Public License, which is a copyleft license designed for free software.
We have designed this License in order to use it for manuals for free software, because free software needs free documentation: a free program should come with manuals providing the same freedoms that the software does. But this License is not limited to software manuals; it can be used for any textual work, regardless of subject matter or whether it is published as a printed book. We recommend this License principally for works whose purpose is instruction or reference.
- APPLICABILITY AND DEFINITIONS
This License applies to any manual or other work, in any medium, that contains a notice placed by the copyright holder saying it can be distributed under the terms of this License. Such a notice grants a world-wide, royalty-free license, unlimited in duration, to use that work under the conditions stated herein. The “Document”, below, refers to any such manual or work. Any member of the public is a licensee, and is addressed as “you”. You accept the license if you copy, modify or distribute the work in a way requiring permission under copyright law.
A “Modified Version” of the Document means any work containing the Document or a portion of it, either copied verbatim, or with modifications and/or translated into another language.
A “Secondary Section” is a named appendix or a front-matter section of the Document that deals exclusively with the relationship of the publishers or authors of the Document to the Document’s overall subject (or to related matters) and contains nothing that could fall directly within that overall subject. (Thus, if the Document is in part a textbook of mathematics, a Secondary Section may not explain any mathematics.) The relationship could be a matter of historical connection with the subject or with related matters, or of legal, commercial, philosophical, ethical or political position regarding them.
The “Invariant Sections” are certain Secondary Sections whose titles are designated, as being those of Invariant Sections, in the notice that says that the Document is released under this License. If a section does not fit the above definition of Secondary then it is not allowed to be designated as Invariant. The Document may contain zero Invariant Sections. If the Document does not identify any Invariant Sections then there are none.
The “Cover Texts” are certain short passages of text that are listed, as Front-Cover Texts or Back-Cover Texts, in the notice that says that the Document is released under this License. A Front-Cover Text may be at most 5 words, and a Back-Cover Text may be at most 25 words.
A “Transparent” copy of the Document means a machine-readable copy, represented in a format whose specification is available to the general public, that is suitable for revising the document straightforwardly with generic text editors or (for images composed of pixels) generic paint programs or (for drawings) some widely available drawing editor, and that is suitable for input to text formatters or for automatic translation to a variety of formats suitable for input to text formatters. A copy made in an otherwise Transparent file format whose markup, or absence of markup, has been arranged to thwart or discourage subsequent modification by readers is not Transparent. An image format is not Transparent if used for any substantial amount of text. A copy that is not “Transparent” is called “Opaque”.
Examples of suitable formats for Transparent copies include plain ASCII without markup, Texinfo input format, LaTeX input format, SGML or XML using a publicly available DTD, and standard-conforming simple HTML, PostScript or PDF designed for human modification. Examples of transparent image formats include PNG, XCF and JPG. Opaque formats include proprietary formats that can be read and edited only by proprietary word processors, SGML or XML for which the DTD and/or processing tools are not generally available, and the machine-generated HTML, PostScript or PDF produced by some word processors for output purposes only.
The “Title Page” means, for a printed book, the title page itself, plus such following pages as are needed to hold, legibly, the material this License requires to appear in the title page. For works in formats which do not have any title page as such, “Title Page” means the text near the most prominent appearance of the work’s title, preceding the beginning of the body of the text.
A section “Entitled XYZ” means a named subunit of the Document whose title either is precisely XYZ or contains XYZ in parentheses following text that translates XYZ in another language. (Here XYZ stands for a specific section name mentioned below, such as “Acknowledgements”, “Dedications”, “Endorsements”, or “History”.) To “Preserve the Title” of such a section when you modify the Document means that it remains a section “Entitled XYZ” according to this definition.
The Document may include Warranty Disclaimers next to the notice which states that this License applies to the Document. These Warranty Disclaimers are considered to be included by reference in this License, but only as regards disclaiming warranties: any other implication that these Warranty Disclaimers may have is void and has no effect on the meaning of this License.
- VERBATIM COPYING
You may copy and distribute the Document in any medium, either commercially or noncommercially, provided that this License, the copyright notices, and the license notice saying this License applies to the Document are reproduced in all copies, and that you add no other conditions whatsoever to those of this License. You may not use technical measures to obstruct or control the reading or further copying of the copies you make or distribute. However, you may accept compensation in exchange for copies. If you distribute a large enough number of copies you must also follow the conditions in section 3.
You may also lend copies, under the same conditions stated above, and you may publicly display copies.
- COPYING IN QUANTITY
If you publish printed copies (or copies in media that commonly have printed covers) of the Document, numbering more than 100, and the Document’s license notice requires Cover Texts, you must enclose the copies in covers that carry, clearly and legibly, all these Cover Texts: Front-Cover Texts on the front cover, and Back-Cover Texts on the back cover. Both covers must also clearly and legibly identify you as the publisher of these copies. The front cover must present the full title with all words of the title equally prominent and visible. You may add other material on the covers in addition. Copying with changes limited to the covers, as long as they preserve the title of the Document and satisfy these conditions, can be treated as verbatim copying in other respects.
If the required texts for either cover are too voluminous to fit legibly, you should put the first ones listed (as many as fit reasonably) on the actual cover, and continue the rest onto adjacent pages.
If you publish or distribute Opaque copies of the Document numbering more than 100, you must either include a machine-readable Transparent copy along with each Opaque copy, or state in or with each Opaque copy a computer-network location from which the general network-using public has access to download using public-standard network protocols a complete Transparent copy of the Document, free of added material. If you use the latter option, you must take reasonably prudent steps, when you begin distribution of Opaque copies in quantity, to ensure that this Transparent copy will remain thus accessible at the stated location until at least one year after the last time you distribute an Opaque copy (directly or through your agents or retailers) of that edition to the public.
It is requested, but not required, that you contact the authors of the Document well before redistributing any large number of copies, to give them a chance to provide you with an updated version of the Document.
- MODIFICATIONS
You may copy and distribute a Modified Version of the Document under the conditions of sections 2 and 3 above, provided that you release the Modified Version under precisely this License, with the Modified Version filling the role of the Document, thus licensing distribution and modification of the Modified Version to whoever possesses a copy of it. In addition, you must do these things in the Modified Version:
- Use in the Title Page (and on the covers, if any) a title distinct from that of the Document, and from those of previous versions (which should, if there were any, be listed in the History section of the Document). You may use the same title as a previous version if the original publisher of that version gives permission.
- List on the Title Page, as authors, one or more persons or entities responsible for authorship of the modifications in the Modified Version, together with at least five of the principal authors of the Document (all of its principal authors, if it has fewer than five), unless they release you from this requirement.
- State on the Title page the name of the publisher of the Modified Version, as the publisher.
- Preserve all the copyright notices of the Document.
- Add an appropriate copyright notice for your modifications adjacent to the other copyright notices.
- Include, immediately after the copyright notices, a license notice giving the public permission to use the Modified Version under the terms of this License, in the form shown in the Addendum below.
- Preserve in that license notice the full lists of Invariant Sections and required Cover Texts given in the Document’s license notice.
- Include an unaltered copy of this License.
- Preserve the section Entitled “History”, Preserve its Title, and add to it an item stating at least the title, year, new authors, and publisher of the Modified Version as given on the Title Page. If there is no section Entitled “History” in the Document, create one stating the title, year, authors, and publisher of the Document as given on its Title Page, then add an item describing the Modified Version as stated in the previous sentence.
- Preserve the network location, if any, given in the Document for public access to a Transparent copy of the Document, and likewise the network locations given in the Document for previous versions it was based on. These may be placed in the “History” section. You may omit a network location for a work that was published at least four years before the Document itself, or if the original publisher of the version it refers to gives permission.
- For any section Entitled “Acknowledgements” or “Dedications”, Preserve the Title of the section, and preserve in the section all the substance and tone of each of the contributor acknowledgements and/or dedications given therein.
- Preserve all the Invariant Sections of the Document, unaltered in their text and in their titles. Section numbers or the equivalent are not considered part of the section titles.
- Delete any section Entitled “Endorsements”. Such a section may not be included in the Modified Version.
- Do not retitle any existing section to be Entitled “Endorsements” or to conflict in title with any Invariant Section.
- Preserve any Warranty Disclaimers.
If the Modified Version includes new front-matter sections or appendices that qualify as Secondary Sections and contain no material copied from the Document, you may at your option designate some or all of these sections as invariant. To do this, add their titles to the list of Invariant Sections in the Modified Version’s license notice. These titles must be distinct from any other section titles.
You may add a section Entitled “Endorsements”, provided it contains nothing but endorsements of your Modified Version by various parties—for example, statements of peer review or that the text has been approved by an organization as the authoritative definition of a standard.
You may add a passage of up to five words as a Front-Cover Text, and a passage of up to 25 words as a Back-Cover Text, to the end of the list of Cover Texts in the Modified Version. Only one passage of Front-Cover Text and one of Back-Cover Text may be added by (or through arrangements made by) any one entity. If the Document already includes a cover text for the same cover, previously added by you or by arrangement made by the same entity you are acting on behalf of, you may not add another; but you may replace the old one, on explicit permission from the previous publisher that added the old one.
The author(s) and publisher(s) of the Document do not by this License give permission to use their names for publicity for or to assert or imply endorsement of any Modified Version.
- COMBINING DOCUMENTS
You may combine the Document with other documents released under this License, under the terms defined in section 4 above for modified versions, provided that you include in the combination all of the Invariant Sections of all of the original documents, unmodified, and list them all as Invariant Sections of your combined work in its license notice, and that you preserve all their Warranty Disclaimers.
The combined work need only contain one copy of this License, and multiple identical Invariant Sections may be replaced with a single copy. If there are multiple Invariant Sections with the same name but different contents, make the title of each such section unique by adding at the end of it, in parentheses, the name of the original author or publisher of that section if known, or else a unique number. Make the same adjustment to the section titles in the list of Invariant Sections in the license notice of the combined work.
In the combination, you must combine any sections Entitled “History” in the various original documents, forming one section Entitled “History”; likewise combine any sections Entitled “Acknowledgements”, and any sections Entitled “Dedications”. You must delete all sections Entitled “Endorsements.”
- COLLECTIONS OF DOCUMENTS
You may make a collection consisting of the Document and other documents released under this License, and replace the individual copies of this License in the various documents with a single copy that is included in the collection, provided that you follow the rules of this License for verbatim copying of each of the documents in all other respects.
You may extract a single document from such a collection, and distribute it individually under this License, provided you insert a copy of this License into the extracted document, and follow this License in all other respects regarding verbatim copying of that document.
- AGGREGATION WITH INDEPENDENT WORKS
A compilation of the Document or its derivatives with other separate and independent documents or works, in or on a volume of a storage or distribution medium, is called an “aggregate” if the copyright resulting from the compilation is not used to limit the legal rights of the compilation’s users beyond what the individual works permit. When the Document is included in an aggregate, this License does not apply to the other works in the aggregate which are not themselves derivative works of the Document.
If the Cover Text requirement of section 3 is applicable to these copies of the Document, then if the Document is less than one half of the entire aggregate, the Document’s Cover Texts may be placed on covers that bracket the Document within the aggregate, or the electronic equivalent of covers if the Document is in electronic form. Otherwise they must appear on printed covers that bracket the whole aggregate.
- TRANSLATION
Translation is considered a kind of modification, so you may distribute translations of the Document under the terms of section 4. Replacing Invariant Sections with translations requires special permission from their copyright holders, but you may include translations of some or all Invariant Sections in addition to the original versions of these Invariant Sections. You may include a translation of this License, and all the license notices in the Document, and any Warranty Disclaimers, provided that you also include the original English version of this License and the original versions of those notices and disclaimers. In case of a disagreement between the translation and the original version of this License or a notice or disclaimer, the original version will prevail.
If a section in the Document is Entitled “Acknowledgements”, “Dedications”, or “History”, the requirement (section 4) to Preserve its Title (section 1) will typically require changing the actual title.
- TERMINATION
You may not copy, modify, sublicense, or distribute the Document except as expressly provided for under this License. Any other attempt to copy, modify, sublicense or distribute the Document is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance.
- FUTURE REVISIONS OF THIS LICENSE
The Free Software Foundation may publish new, revised versions of the GNU Free Documentation License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. See http://www.gnu.org/copyleft/.
Each version of the License is given a distinguishing version number. If the Document specifies that a particular numbered version of this License “or any later version” applies to it, you have the option of following the terms and conditions either of that specified version or of any later version that has been published (not as a draft) by the Free Software Foundation. If the Document does not specify a version number of this License, you may choose any version ever published (not as a draft) by the Free Software Foundation.
ADDENDUM: How to use this License for your documents
To use this License in a document you have written, include a copy of the License in the document and put the following copyright and license notices just after the title page:
Copyright (C) year your name. Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.2 or any later version published by the Free Software Foundation; with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. A copy of the license is included in the section entitled ``GNU Free Documentation License''.
If you have Invariant Sections, Front-Cover Texts and Back-Cover Texts, replace the “with…Texts.” line with this:
with the Invariant Sections being list their titles, with
the Front-Cover Texts being list, and with the Back-Cover Texts
being list.
If you have Invariant Sections without Cover Texts, or some other combination of the three, merge those two alternatives to suit the situation.
If your document contains nontrivial examples of program code, we recommend releasing these examples in parallel under your choice of free software license, such as the GNU General Public License, to permit their use in free software.
Previous: Copying This Manual, Up: Top [Contents][Index]
Индекс
| Jump to: | A B C D E F G H I J L M N O P Q R S T V W X Y Z Н О С Т Ц |
|---|
| Jump to: | A B C D E F G H I J L M N O P Q R S T V W X Y Z Н О С Т Ц |
|---|