Руководство по Математическому инструменту Genius.

# Руководство пользователя Genius

1997-2021
Jiří (George) Lebl
2004
Kai Willadsen

Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License (GFDL), Version 1.1 or any later version published by the Free Software Foundation with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. You can find a copy of the GFDL at this link or in the file COPYING-DOCS distributed with this manual.

This manual is part of a collection of GNOME manuals distributed under the GFDL. If you want to distribute this manual separately from the collection, you can do so by adding a copy of the license to the manual, as described in section 6 of the license.

Many of the names used by companies to distinguish their products and services are claimed as trademarks. Where those names appear in any GNOME documentation, and the members of the GNOME Documentation Project are made aware of those trademarks, then the names are in capital letters or initial capital letters.

DOCUMENT AND MODIFIED VERSIONS OF THE DOCUMENT ARE PROVIDED UNDER THE TERMS OF THE GNU FREE DOCUMENTATION LICENSE WITH THE FURTHER UNDERSTANDING THAT:

1. DOCUMENT IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES THAT THE DOCUMENT OR MODIFIED VERSION OF THE DOCUMENT IS FREE OF DEFECTS MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY, ACCURACY, AND PERFORMANCE OF THE DOCUMENT OR MODIFIED VERSION OF THE DOCUMENT IS WITH YOU. SHOULD ANY DOCUMENT OR MODIFIED VERSION PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT THE INITIAL WRITER, AUTHOR OR ANY CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. NO USE OF ANY DOCUMENT OR MODIFIED VERSION OF THE DOCUMENT IS AUTHORIZED HEREUNDER EXCEPT UNDER THIS DISCLAIMER; AND

2. UNDER NO CIRCUMSTANCES AND UNDER NO LEGAL THEORY, WHETHER IN TORT (INCLUDING NEGLIGENCE), CONTRACT, OR OTHERWISE, SHALL THE AUTHOR, INITIAL WRITER, ANY CONTRIBUTOR, OR ANY DISTRIBUTOR OF THE DOCUMENT OR MODIFIED VERSION OF THE DOCUMENT, OR ANY SUPPLIER OF ANY OF SUCH PARTIES, BE LIABLE TO ANY PERSON FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES OF ANY CHARACTER INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF GOODWILL, WORK STOPPAGE, COMPUTER FAILURE OR MALFUNCTION, OR ANY AND ALL OTHER DAMAGES OR LOSSES ARISING OUT OF OR RELATING TO USE OF THE DOCUMENT AND MODIFIED VERSIONS OF THE DOCUMENT, EVEN IF SUCH PARTY SHALL HAVE BEEN INFORMED OF THE POSSIBILITY OF SUCH DAMAGES.

Jiří
Lebl
Oklahoma State University

     jiri.lebl@gmail.com

Kai
Willadsen
University of Queensland, Australia

     kaiw@itee.uq.edu.au

0.2
October 2021

Jiri (George) Lebl jiri.lebl@gmail.com

This manual describes version 1.0.27 of Genius.

## Обратная связь

To report a bug or make a suggestion regarding the Genius Mathematics Tool application or this manual, please visit the Genius Web page or email me at jiri.lebl@gmail.com.

## Введение

The Genius Mathematics Tool application is a general calculator for use as a desktop calculator, an educational tool in mathematics and other STEM fields, and has found use in research. The language used in Genius Mathematics Tool is designed to be ‘mathematical’ in the sense that it should be ‘what you mean is what you get’. Of course, that is not an entirely attainable goal. Genius Mathematics Tool features rationals, arbitrary precision integers and multiple precision floats using the GMP library. It handles complex numbers using cartesian notation. It has good vector and matrix manipulation and can handle basic linear algebra. The programming language allows user defined functions, variables, and parameters.

Genius Mathematics Tool comes in two versions. One version is the graphical GNOME version, which features an IDE style interface and the ability to plot functions of one or two variables. Parametric plots of curves are also supported. It can plot slope fields, vector fields and draw their solutions. The plots can be exported to several formats. The command line version does not require GNOME, but does not implement any feature that requires the graphical interface, such as plotting

Parts of this manual describe the graphical version of the calculator. The language that both versions use is the same, it is simply the graphical features such as plotting that are unique to the GUI version.

Generally, when some feature of the language (function, operator, etc...) is new in some version past 1.0.5, it is mentioned, but below 1.0.5 you would have to look at the NEWS file.

## Приступая к работе

### Запуск Математического инструмента Genius

You can start Genius Mathematics Tool in the following ways:

Меню Приложения

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

Диалог запуска

  В некоторых операционных системах упомянутая выше команда меню может быть недоступна. В этом случае можно открыть диалог запуска и выполнить команду `gnome-genius`.

Командная строка

  Чтобы запустить версию Математического инструмента Genius для GNOME, выполните в командной строке `gnome-genius`.

  Чтобы запустить версию для командной строки, выполните следующую команду: `genius`. Эта версия не содержит графического интерфейса и некоторые возможности, такие как построение графиков, будут в ней недоступны.

### После запуска Genius

После запуска версии Математического инструмента Genius для GNOME появится окно, изображённое на иллюстрации .

#### Окно Математического инструмента Genius

Shows Genius Mathematics Tool main window. Contains titlebar, menubar, toolbar and working area. Menubar contains File, Edit, Calculator, Examples, Programs, Settings, and Help menus.

Окно Математического инструмента Genius содержит следующие элементы:

Строка меню.

  Строка меню содержит все команды, необходимые для работы с файлами в Математическом инструменте Genius. Меню Файл содержит команды для загрузки и сохранения объектов и создания новых программ. Команда Загрузить и выполнить... не открывает новое окно для программы, а просто сразу выполняет программу. Её действие эквивалентно действию команды `load`.

  The Calculator menu controls the calculator engine. It allows you to run the currently selected program or to interrupt the current calculation. You can also look at the full expression of the last answer (useful if the last answer was too large to fit onto the console), or you can view a listing of the values of all user defined variables. You can also monitor user variables, which is especially useful while a long calculation is running, or to debug a certain program. Finally the Calculator allows plotting functions using a user friendly dialog box.

  The Examples menu is a list of example programs or demos. If you open the menu, it will load the example into a new program, which you can run, edit, modify, and save. These programs should be well documented and generally demonstrate either some feature of Genius Mathematics Tool or some mathematical concept.

  The Programs menu lists the currently open programs and allows you to switch between them.

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

Панель инструментов.

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

Рабочая область

  Рабочая область — основной способ взаимодействия с приложением.

  The working area initially has just the Console tab, which is the main way of interacting with the calculator. Here you type expressions and the results are immediately returned after you hit the Enter key.

  Alternatively you can write longer programs and those can appear in separate tabs. The programs are a set of commands or functions that can be run all at once rather than entering them at the command line. The programs can be saved in files for later retrieval.

## Основы работы с программой

### Использование рабочей области

Normally you interact with the calculator in the Console tab of the work area. If you are running the text only version then the console will be the only thing that is available to you. If you want to use Genius Mathematics Tool as a calculator only, just type in your expression in the console, it will be evaluated, and the returned value will be printed.

To evaluate an expression, type it into the Console work area and press enter. Expressions are written in a language called GEL. The most simple GEL expressions just looks like mathematics. For example

    genius> 30*70 + 67^3.0 + ln(7) * (88.8/100)

or

    genius> 62734 + 812634 + 77^4 mod 5

or

    genius> | sin(37) - e^7 |

or

    genius> sum n=1 to 70 do 1/n

(Last is the harmonic sum from 1 to 70)

To get a list of functions and commands, type:

    genius> help

If you wish to get more help on a specific function, type:

    genius> help FunctionName

To view this manual, type:

    genius> manual

Suppose you have previously saved some GEL commands as a program to a file and you now want to execute them. To load this program from the file `path/to/program.gel`, type

    genius> load path/to/program.gel

Genius Mathematics Tool keeps track of the current directory. To list files in the current directory type `ls`, to change directory do `cd directory` as in the UNIX command shell.

### Создание новой программы

If you wish to enter several more complicated commands, or perhaps write a complicated function using the GEL language, you can create a new program; really just a file with many commands.

To start writing a new program, choose File New Program. A new tab will appear in the work area. You can write a GEL program in this work area. Once you have written your program you can run it by Calculator Run (or the Run toolbar button). This will execute your program and will display any output on the Console tab. Executing a program is equivalent of taking the text of the program and typing it into the console. The only difference is that this input is done independent of the console and just the output goes onto the console. Calculator Run will always run the currently selected program even if you are on the Console tab. The currently selected program has its tab in bold type. To select a program, just click on its tab.

To save the program you've just written, choose File Save As.... Similarly as in other programs you can choose File Save to save a program that already has a filename attached to it. If you have many opened programs you have edited and wish to save you can also choose File Save All Unsaved.

Programs that have unsaved changes will have a "[+]" next to their filename. This way you can see if the file on disk and the currently opened tab differ in content. Programs which have not yet had a filename associated with them are always considered unsaved and no "[+]" is printed.

### Открытие и запуск программы

Чтобы открыть файл, выберите Файл Открыть. В рабочей области появится новая вкладка с содержимым файла. Вы можете использовать её для редактирования файла.

Чтобы запустить программу из файла, выберите Файл Загрузить и выполнить.... Это действие запустит программу, не открывая её в отдельной вкладке. Это эквивалентно команде `load`.

If you have made edits to a file you wish to throw away and want to reload to the version that's on disk, you can choose the File Reload from Disk menuitem. This is useful for experimenting with a program and making temporary edits, to run a program, but that you do not intend to keep.

## Построение графиков

Построение графиков поддерживается только в версии с графическим интерфейсом для GNOME. Все варианты графиков, имеющиеся в графическом интерфейсе, доступны из окна Создать график. Чтобы открыть это окно, нажмите кнопку График на панели инструментов или выберите Нарисовать график из меню Калькулятор. Можно также использовать команды построения графиков языка GEL. Смотрите , чтобы узнать, как вводить выражения, которые понимает Genius.

### Линейные графики

To graph real-valued functions of one variable, open the Create Plot window. You can also use the `LinePlot` function on the command line (see its documentation). And by the words line plot, we mean plots in the plane, as opposed to surface plots, which are in three dimensions.

После нажатия кнопки График откроется окно с несколькими вкладками. Вам нужна вкладка Линейный график функции, внутри которой следует выбрать вкладку Функции / Выражения. Смотрите .

#### Create Plot Window

Shows the line plotting window.

Type expressions with `x` as the independent variable into the textboxes. Alternatively you can give names of functions such as `cos` rather then having to type `cos(x)`. You can graph up to ten functions. If you make a mistake and Genius cannot parse the input it will signify this with a warning icon on the right of the text input box where the error occurred, as well as giving you an error dialog. You can change the ranges of the dependent and independent variables in the bottom part of the dialog. In the boxes for the ranges, simple expressions are allowed, such as `2*pi` or `10^3`. The `y` (dependent) range can be set automatically by turning on the Fit dependent axis checkbox. The names of the variables can also be changed. Pressing the Plot button produces the graph shown in .

The variables can be renamed by clicking the Change variable names... button, which is useful if you wish to print or save the figure and don't want to use the standard names. Finally you can also avoid printing the legend and the axis labels completely, which is also useful if printing or saving, when the legend might simply be clutter.

#### Plot Window

The graph produced.

From here you can print out the plot, create encapsulated postscript or a PNG version of the plot or change the zoom. If the dependent axis was not set correctly you can have Genius fit it by finding out the extrema of the graphed functions.

For plotting using the command line see the documentation of the `LinePlot` function.

### Parametric Plots

In the create plot window, you can also choose the Parametric notebook tab to create two dimensional parametric plots. This way you can plot a single parametric function. You can either specify the points as `x` and `y`, or giving a single complex number as a function of the variable `t`. The range of the variable `t` is given explicitly, and the function is sampled according to the given increment. The `x` and `y` range can be set automatically by turning on the Fit dependent axis checkbox, or it can be specified explicitly. See .

#### Parametric Plot Tab

Parametric plotting tab in the Create Plot window.

An example of a parametric plot is given in . Similar operations can be done on such graphs as can be done on the other line plots. For plotting using the command line see the documentation of the `LinePlotParametric` or `LinePlotCParametric` function.

#### Parametric Plot

Parametric plot produced

### Slopefield Plots

In the create plot window, you can also choose the Slope field notebook tab to create a two dimensional slope field plot. Similar operations can be done on such graphs as can be done on the other line plots. For plotting using the command line see the documentation of the `SlopefieldPlot` function.

When a slope field is active, there is an extra Solver menu available, through which you can bring up the solver dialog. Here you can have Genius plot specific solutions for the given initial conditions. You can either specify initial conditions in the dialog, or you can click on the plot directly to specify the initial point. While the solver dialog is active, the zooming by clicking and dragging does not work. You have to close the dialog first if you want to zoom using the mouse.

The solver uses the standard Runge-Kutta method. The plots will stay on the screen until cleared. The solver will stop whenever it reaches the boundary of the plot window. Zooming does not change the limits or parameters of the solutions, you will have to clear and redraw them with appropriate parameters. You can also use the `SlopefieldDrawSolution` function to draw solutions from the command line or programs.

### Vectorfield Plots

In the create plot window, you can also choose the Vector field notebook tab to create a two dimensional vector field plot. Similar operations can be done on such graphs as can be done on the other line plots. For plotting using the command line see the documentation of the `VectorfieldPlot` function.

By default the direction and magnitude of the vector field is shown. To only show direction and not the magnitude, check the appropriate checkbox to normalize the arrow lengths.

When a vector field is active, there is an extra Solver menu available, through which you can bring up the solver dialog. Here you can have Genius plot specific solutions for the given initial conditions. You can either specify initial conditions in the dialog, or you can click on the plot directly to specify the initial point. While the solver dialog is active, the zooming by clicking and dragging does not work. You have to close the dialog first if you want to zoom using the mouse.

The solver uses the standard Runge-Kutta method. The plots will stay on the screen until cleared. Zooming does not change the limits or parameters of the solutions, you will have to clear and redraw them with appropriate parameters. You can also use the `VectorfieldDrawSolution` function to draw solutions from the command line or programs.

### Графики поверхностей

Genius can also plot surfaces. Select the Surface plot tab in the main notebook of the Create Plot window. Here you can specify a single expression that should use either `x` and `y` as real independent variables or `z` as a complex variable (where `x` is the real part of `z` and `y` is the imaginary part). For example to plot the modulus of the cosine function for complex parameters, you could enter `|cos(z)|`. This would be equivalent to `|cos(x+1i*y)|`. See . For plotting using the command line see the documentation of the `SurfacePlot` function.

The `z` range can be set automatically by turning on the Fit dependent axis checkbox. The variables can be renamed by clicking the Change variable names... button, which is useful if you wish to print or save the figure and don't want to use the standard names. Finally you can also avoid printing the legend, which is also useful if printing or saving, when the legend might simply be clutter.

#### Surface Plot

Modulus of the complex cosine function.

In surface mode, left and right arrow keys on your keyboard will rotate the view along the z axis. Alternatively you can rotate along any axis by selecting Rotate axis... in the View menu. The View menu also has a top view mode which rotates the graph so that the z axis is facing straight out, that is, we view the graph from the top and get essentially just the colors that define the values of the function getting a temperature plot of the function. Finally you should try Start rotate animation, to start a continuous slow rotation. This is especially good if using Genius Mathematics Tool to present to an audience.

## Основы GEL

GEL stands for Genius Extension Language. It is the language you use to write programs in Genius. A program in GEL is simply an expression that evaluates to a number, a matrix, or another object in GEL. Genius Mathematics Tool can be used as a simple calculator, or as a powerful theoretical research tool. The syntax is meant to have as shallow of a learning curve as possible, especially for use as a calculator.

### Значения

Values in GEL can be numbers, Booleans, or strings. GEL also treats matrices as values. Values can be used in calculations, assigned to variables and returned from functions, among other uses.

#### Числа

Integers are the first type of number in GEL. Integers are written in the normal way.

    1234

Hexadecimal and octal numbers can be written using C notation. For example:

    0x123ABC
    01234

Or you can type numbers in an arbitrary base using `<base>\<number>`. Digits higher than 10 use letters in a similar way to hexadecimal. For example, a number in base 23 could be written:

    23\1234ABCD

The second type of GEL number is rationals. Rationals are simply achieved by dividing two integers. So one could write:

    3/4

to get three quarters. Rationals also accept mixed fraction notation. So in order to get one and three tenths you could write:

    1 3/10

The next type of number is floating point. These are entered in a similar fashion to C notation. You can use `E`, `e` or `@` as the exponent delimiter. Note that using the exponent delimiter gives a float even if there is no decimal point in the number. Examples:

    1.315
    7.887e77
    7.887e-77
    .3
    0.3
    77e5

When Genius prints a floating point number it will always append a `.0` even if the number is whole. This is to indicate that floating point numbers are taken as imprecise quantities. When a number is written in the scientific notation, it is always a floating point number and thus Genius does not print the `.0`.

The final type of number in GEL is the complex numbers. You can enter a complex number as a sum of real and imaginary parts. To add an imaginary part, append an `i`. Here are examples of entering complex numbers:

    1+2i
    8.01i
    77*e^(1.3i)

При вводе мнимых чисел перед символом `i` должно стоять число. Если использовать символ `i` сам по себе, Genius интерпретирует его как ссылку на переменную `i`. Если нужно указать саму мнимую единицу `i`, используйте вместо неё `1i`.

Чтобы использовать смешанные дроби в мнимых числах, нужно взять смешанную дробь в круглые скобки: (например, `(1 2/5)i`)

#### Логические значения

Genius также поддерживает логические значения. Определены две логические константы: `true` и `false`; их можно использовать, как и любую переменную. В качестве псевдонимов к ним можно также использовать `True`, `TRUE`, `False` и `FALSE`.

Там, где требуется логическое выражение, можно использовать логическое значение или любое выражение, дающее в результате число или логическое значение. Если Genius нужно использовать число как логическое значение, он будет интерпретировать 0 как `false` и любое другое число как `true`.

In addition, you can do arithmetic with Boolean values. For example:

    ( (1 + true) - false ) * true

is the same as:

    ( (true or true) or not false ) and true

Only addition, subtraction and multiplication are supported. If you mix numbers with Booleans in an expression then the numbers are converted to Booleans as described above. This means that, for example:

    1 == true

always evaluates to `true` since 1 will be converted to `true` before being compared to `true`.

#### Строки

Like numbers and Booleans, strings in GEL can be stored as values inside variables and passed to functions. You can also concatenate a string with another value using the plus operator. For example:

    a=2+3;"The result is: "+a

will create the string:

    The result is: 5

You can also use C-like escape sequences such as `\n`,`\t`,`\b`,`\a` and `\r`. To get a `\` or `"` into the string you can quote it with a `\`. For example:

    "Slash: \\ Quotes: \" Tabs: \t1\t2\t3"

will make a string:

    Slash: \ Quotes: " Tabs: 	1	2	3

Do note however that when a string is returned from a function, escapes are quoted, so that the output can be used as input. If you wish to print the string as it is (without escapes), use the `print` or `printn` functions.

In addition, you can use the library function `string` to convert anything to a string. For example:

    string(22)

will return

    "22"

Strings can also be compared with `==` (equal), `!=` (not equal) and `<=>` (comparison) operators

#### Null

There is a special value called `null`. No operations can be performed on it, and nothing is printed when it is returned. Therefore, `null` is useful when you do not want output from an expression. The value `null` can be obtained as an expression when you type `.`, the constant `null` or nothing. By nothing we mean that if you end an expression with a separator `;`, it is equivalent to ending it with a separator followed by a `null`.

Example:

    x=5;.
    x=5;

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

### Использование переменных

Syntax:

    VariableName

Example:

    genius> e
    = 2.71828182846

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

#### Использование автозавершения по клавише Tab

Вы можете использовать автозавершение по нажатию клавиши Tab, чтобы Genius автоматически подставлял полное имя переменной. Попробуйте набрать несколько первых букв имени и нажать `Tab`.

#### Имена переменных чувствительны к регистру

Имена переменных чувствительны к регистру символов. Это означает, что переменные `hello`, `HELLO` и `Hello` — это разные переменные.

#### Присваивание значения переменным

Syntax:

    <identifier> = <value>
    <identifier> := <value>

Example:

    x = 3
    x := 3

To assign a value to a variable, use the `=` or `:=` operators. These operators set the value of the variable and return the value you set, so you can do things like

    a = b = 5

This will set `b` to 5 and then also set `a` to 5.

Для присваивания значения переменным можно использовать любой из операторов `=` и `:=`. Различие между ними в том, что оператор `:=` всегда действует как оператор присваивания, а оператор `=` может интерпретироваться как проверка на равенство там, где ожидается логическое выражение.

For more information about the scope of variables, that is when are what variables visible, see .

#### Встроенные переменные

GEL has a number of built-in ‘variables’, such as `e`, `pi` or `GoldenRatio`. These are widely used constants with a preset value, and they cannot be assigned new values. There are a number of other built-in variables. See for a full list. Note that `i` is not by default the square root of negative one (the imaginary number), and is undefined to allow its use as a counter. If you wish to write the imaginary number you need to use `1i`.

#### Переменные с результатом предыдущего вычисления

The `Ans` and `ans` variables can be used to get the result of the last expression. For example, if you had performed some calculation, to add 389 to the result you could do:

    Ans+389

### Использование функций

Syntax:

    FunctionName(argument1, argument2, ...)

Example:

    Factorial(5)
    cos(2*pi)
    gcd(921,317)

To evaluate a function, enter the name of the function, followed by the arguments (if any) to the function in parentheses. This will return the result of applying the function to its arguments. The number of arguments to the function is, of course, different for each function.

There are many built-in functions, such as `sin`, `cos` and `tan`. You can use the `help` built-in command to get a list of available functions, or see for a full listing.

#### Использование автозавершения по клавише Tab

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

#### Имена функций чувствительны к регистру

Имена функций чувствительны к регистру символов. Это означает, что функции `dosomething`, `DOSOMETHING` и `DoSomething` — это разные функции.

#### Определение функций

Syntax:

    function <identifier>(<comma separated arguments>) = <function body>
    <identifier> = (`() = <function body>)

The ``` is the backquote character, and signifies an anonymous function. By setting it to a variable name you effectively define a function.

A function takes zero or more comma separated arguments, and returns the result of the function body. Defining your own functions is primarily a matter of convenience; one possible use is to have sets of functions defined in GEL files that Genius can load in order to make them available. Example:

    function addup(a,b,c) = a+b+c

then `addup(1,4,9)` yields 14

#### Variable Argument Lists

If you include `...` after the last argument name in the function declaration, then Genius will allow any number of arguments to be passed in place of that argument. If no arguments were passed then that argument will be set to `null`. Otherwise, it will be a horizontal vector containing all the arguments. For example:

    function f(a,b...) = b

Then `f(1,2,3)` yields `[2,3]`, while `f(1)` yields a `null`.

#### Passing Functions to Functions

In Genius, it is possible to pass a function as an argument to another function. This can be done using either ‘function nodes’ or anonymous functions.

If you do not enter the parentheses after a function name, instead of being evaluated, the function will instead be returned as a ‘function node’. The function node can then be passed to another function. Example:

    function f(a,b) = a(b)+1;
    function b(x) = x*x;
    f(b,2)

To pass functions that are not defined, you can use an anonymous function (see ). That is, you want to pass a function without giving it a name. Syntax:

    function(<comma separated arguments>) = <function body>
    `(<comma separated arguments>) = <function body>

Example:

    function f(a,b) = a(b)+1;
    f(`(x) = x*x,2)

This will return 5.

#### Операции с функциями

Some functions allow arithmetic operations, and some single argument functions such as `exp` or `ln`, to operate on the function. For example,

    exp(sin*cos+4)

will return a function that takes `x` and returns `exp(sin(x)*cos(x)+4)`. It is functionally equivalent to typing

    `(x) = exp(sin(x)*cos(x)+4)

This operation can be useful when quickly defining functions. For example to create a function called `f` to perform the above operation, you can just type:

    f = exp(sin*cos+4)

It can also be used in plotting. For example, to plot sin squared you can enter:

    LinePlot(sin^2)

Not all functions can be used in this way. For example, when you use a binary operation the functions must take the same number of arguments.

### Разделитель

GEL is somewhat different from other languages in how it deals with multiple commands and functions. In GEL you must chain commands together with a separator operator. That is, if you want to type more than one expression you have to use the `;` operator in between the expressions. This is a way in which both expressions are evaluated and the result of the second one (or the last one if there is more than two expressions) is returned. Suppose you type the following:

    3 ; 5

This expression will yield 5.

This will require some parenthesizing to make it unambiguous sometimes, especially if the `;` is not the top most primitive. This slightly differs from other programming languages where the `;` is a terminator of statements, whereas in GEL it’s actually a binary operator. If you are familiar with pascal this should be second nature. However genius can let you pretend it is a terminator to some degree. If a `;` is found at the end of a parenthesis or a block, genius will append a null to it as if you would have written `;null`. This is useful in case you do not want to return a value from a loop, or if you handle the return differently.

If you are typing expressions in a program file you do not have to add a semicolon. In this case genius will simply print the return value whenever it executes the expression. This is the same as when typing on the command line. However, do note that if you are defining a function, the body of the function is a single expression. Usually, therefore, if a function body is long, you will need to enclose it in parentheses.

### Comments

GEL is similar to other scripting languages in that `#` denotes a comment, that is text that is not meant to be evaluated. Everything beyond the pound sign till the end of line will just be ignored. For example,

    # This is just a comment
    # every line in a comment must have its own pound sign
    # in the next line we set x to the value 123
    x=123;

### Modular Evaluation

Genius implements modular arithmetic. To use it you just add "mod <integer>" after the expression. Example: `2^(5!) * 3^(6!) mod 5` It could be possible to do modular arithmetic by computing with integers and then modding in the end with the `%` operator, which simply gives the remainder, but that may be time consuming if not impossible when working with larger numbers. For example, `10^(10^10) % 6` will simply not work (the exponent will be too large), while `10^(10^10) mod 6` is instantaneous. The first expression first tries to compute the integer `10^(10^10)` and then find remainder after division by 6, while the second expression evaluates everything modulo 6 to begin with.

The inverses of numbers mod some integer are computed by writing them as rational numbers (as long as the desired inverse exists, of course). Examples:

    10^-1 mod 101
    1/10 mod 101

Modular evaluation also works with matrices including taking inverses, powers, and dividing. Example:

    A = [1,2;3,4]
    B = A^-1 mod 5
    A*B mod 5

This should yield the identity matrix as B will be the inverse of A mod 5.

Some functions such as `sqrt` or `log` work in a different way when in modulo mode. These will then work like their discrete versions working within the ring of integers you selected. For example:

    genius> sqrt(4) mod 7
    =
    [2, 5]
    genius> 2*2 mod 7
    = 4

`sqrt` will actually return all the possible square roots.

Do not chain mod operators, simply place it at the end of the computation, all computations in the expression on the left will be carried out in mod arithmetic. If you place a mod inside a mod, you will get unexpected results. If you simply want to mod a single number and control exactly when remainders are taken, best to use the `%` operator. When you need to chain several expressions in modular arithmetic with different divisors, it may be best to just split up the expression into several and use temporary variables to avoid a mod inside a mod.

### Список операторов GEL

Everything in GEL is really just an expression. Expressions are stringed together with different operators. As we have seen, even the separator is simply a binary operator in GEL. Here is a list of the operators in GEL.

`a;b`

  Разделитель, просто вычисляющий как `a`, так и `b`, но возвращающий только результат `b`.

`a=b`

  The assignment operator. This assigns `b` to `a` (`a` must be a valid lvalue) (note however that this operator may be translated to `==` if used in a place where boolean expression is expected)

`a:=b`

  The assignment operator. Assigns `b` to `a` (`a` must be a valid lvalue). This is different from `=` because it never gets translated to a `==`.

`|a|`

  Absolute value. In case the expression is a complex number the result will be the modulus (distance from the origin). For example: `|3 * e^(1i*pi)|` returns 3.

  Смотрите Mathworld для дополнительной информации.

`a^b`

  Возводит переменную `a` в степень `b`.

`a.^b`

  Поэлементное возведение в степень. Возводит каждый элемент матрицы `a` в степень `b`. Или, если `b` — матрица той же размерности, что и `a`, выполняет операцию поэлементно. Если `a` — число, а `b` — матрица, то создаёт матрицу той же размерности, что и `b` со значением `a`, возведённым во все степени, содержащиеся в `b`.

`a+b`

  Addition. Adds two numbers, matrices, functions or strings. If you add a string to anything the result will just be a string. If one is a square matrix and the other a number, then the number is multiplied by the identity matrix.

`a-b`

  Вычитание. Вычитает два числа, матрицы или функции.

`a*b`

  Умножение. Это обычное умножение матриц.

`a.*b`

  Поэлементное умножение, если `a` и `b` являются матрицами.

`a/b`

  Division. When `a` and `b` are just numbers this is the normal division. When they are matrices, then this is equivalent to `a*b^-1`.

`a./b`

  Element by element division. Same as `a/b` for numbers, but operates element by element on matrices.

`a\b`

  Обратное деление. Это то же самое, что `b/a`.

`a.\b`

  Поэлементное обратное деление.

`a%b`

  The mod operator. This does not turn on the modular mode, but just returns the remainder of integer division `a/b`.

`a.%b`

  Element by element mod operator. Returns the remainder after element by element integer division `a./b`.

`a mod b`

  Modular evaluation operator. The expression `a` is evaluated modulo `b`. See . Some functions and operators behave differently modulo an integer.

`a!`

  Факториал: `1*...*(n-2)*(n-1)*n`.

`a!!`

  Двойной факториал: `1*...*(n-4)*(n-2)*n`.

`a==b`

  Equality operator. Returns `true` or `false` depending on `a` and `b` being equal or not.

`a!=b`

  Оператор неравенства, возвращает `true`, если `a` не равно `b`, в противном случае возвращает `false`.

`a<>b`

  Альтернативный оператор неравенства, возвращает `true`, если `a` не равно `b`, иначе возвращает `false`.

`a<=b`

  Less than or equal operator, returns `true` if `a` is less than or equal to `b` else returns `false`. These can be chained as in `a <= b <= c` (can also be combined with the less than operator).

`a>=b`

  Greater than or equal operator, returns `true` if `a` is greater than or equal to `b` else returns `false`. These can be chained as in `a >= b >= c` (and they can also be combined with the greater than operator).

`a<b`

  Less than operator, returns `true` if `a` is less than `b` else returns `false`. These can be chained as in `a < b < c` (they can also be combined with the less than or equal to operator).

`a>b`

  Greater than operator, returns `true` if `a` is greater than `b` else returns `false`. These can be chained as in `a > b > c` (they can also be combined with the greater than or equal to operator).

`a<=>b`

  Оператор сравнения. Если `a` равно `b`, возвращает 0; если `a` меньше `b`, возвращает -1; если `a` больше `b`, возвращает 1.

`a and b`

  Logical and. Returns true if both `a` and `b` are true, else returns false. If given numbers, nonzero numbers are treated as true.

`a or b`

  Logical or. Returns true if either `a` or `b` is true, else returns false. If given numbers, nonzero numbers are treated as true.

`a xor b`

  Logical xor. Returns true if exactly one of `a` or `b` is true, else returns false. If given numbers, nonzero numbers are treated as true.

`not a`

  Logical not. Returns the logical negation of `a`.

`-a`

  Negation operator. Returns the negative of a number or a matrix (works element-wise on a matrix).

`&a`

  Variable referencing (to pass a reference to a variable). See .

`*a`

  Variable dereferencing (to access a referenced variable). See .

`a'`

  Matrix conjugate transpose. That is, rows and columns get swapped and we take complex conjugate of all entries. That is if the i,j element of `a` is x+iy, then the j,i element of `a'` is x-iy.

`a.'`

  Matrix transpose, does not conjugate the entries. That is, the i,j element of `a` becomes the j,i element of `a.'`.

`a@(b,c)`

  Get element of a matrix in row `b` and column `c`. If `b`, `c` are vectors, then this gets the corresponding rows, columns or submatrices.

`a@(b,)`

  Get row of a matrix (or multiple rows if `b` is a vector).

`a@(b,:)`

  То же, что и выше.

`a@(,c)`

  Возвращает столбец матрицы (или столбцы, если `c` является вектором).

`a@(:,c)`

  То же, что и выше.

`a@(b)`

  Get an element from a matrix treating it as a vector. This will traverse the matrix row-wise.

`a:b`

  Build a vector from `a` to `b` (or specify a row, column region for the `@` operator). For example to get rows 2 to 4 of matrix `A` we could do

      A@(2:4,)

  as `2:4` will return a vector `[2,3,4]`.
`a:b:c`

  Build a vector from `a` to `c` with `b` as a step. That is for example

      genius> 1:2:9
      =
      `[1, 3, 5, 7, 9]

  When the numbers involved are floating point numbers, for example `1.0:0.4:3.0`, the output is what is expected even though adding 0.4 to 1.0 five times is actually just slightly more than 3.0 due to the way that floating point numbers are stored in base 2 (there is no 0.4, the actual number stored is just ever so slightly bigger). The way this is handled is the same as in the for, sum, and prod loops. If the end is within `2^-20` times the step size of the endpoint, the endpoint is used and we assume there were roundoff errors. This is not perfect, but it handles the majority of the cases. This check is done only from version 1.0.18 onwards, so execution of your code may differ on older versions. If you want to avoid dealing with this issue, use actual rational numbers, possibly using the `float` if you wish to get floating point numbers in the end. For example `1:2/5:3` does the right thing and `float(1:2/5:3)` even gives you floating point numbers and is ever so slightly more precise than `1.0:0.4:3.0`.

`(a)i`

  Make `a` into an imaginary number (multiply `a` by the imaginary). Normally the imaginary number `i` is written as `1i`. So the above is equal to

      (a)*1i

``a`

  Quote an identifier so that it doesn't get evaluated. Or quote a matrix so that it doesn't get expanded.

`a swapwith b`

  Меняет местами значение `a` со значением `b`. В настоящее время не работает с диапазонами элементов матрицы. Возвращает `null`. Доступен, начиная с версии 1.0.13.

`increment a`

  Инкремент переменной `a` на 1. Если `a` — матрица, то инкрементирует каждый элемент. Это эквивалентно `a=a+1`, но немного быстрее. Возвращает `null`. Доступен с версии 1.0.13.

`increment a by b`

  Инкремент переменной `a` на величину `b`. Если `a` — матрица, то инкрементирует каждый элемент. Это эквивалентно `a=a+b`, но немного быстрее. Возвращает `null`. Доступен с версии 1.0.13.

Оператор @() делает использование оператора : наиболее полезным. С его помощью можно указывать области матрицы. Таким образом, a@(2:4,6) — это строки 2,3,4 столбца 6. Или a@(,1:2) возвращает два первых столбца матрицы. Можно также присваивать значения оператору @(), если правое значение — это матрица, совпадающая по размеру с данной областью, или если это любой другой тип значений.

The comparison operators (except for the <=> operator, which behaves normally), are not strictly binary operators, they can in fact be grouped in the normal mathematical way, e.g.: (1<x<=y<5) is a legal boolean expression and means just what it should, that is (1<x and x≤y and y<5)

The unitary minus operates in a different fashion depending on where it appears. If it appears before a number it binds very closely, if it appears in front of an expression it binds less than the power and factorial operators. So for example `-1^k` is really `(-1)^k`, but `-foo(1)^k` is really `-(foo(1)^k)`. So be careful how you use it and if in doubt, add parentheses.

## Программирование в GEL

### Условные операторы

Syntax:

    if <expression1> then <expression2> [else <expression3>]

If `else` is omitted, then if the `expression1` yields `false` or 0, `NULL` is returned.

Examples:

    if(a==5)then(a=a-1)
    if b<a then b=a
    if c>0 then c=c-1 else c=0
    a = ( if b>0 then b else 1 )

Note that `=` will be translated to `==` if used inside the expression for `if`, so

    if a=5 then a=a-1

will be interpreted as:

    if a==5 then a:=a-1

### Циклы

#### Циклы While

Syntax:

    while <expression1> do <expression2>
    until <expression1> do <expression2>
    do <expression2> while <expression1>
    do <expression2> until <expression1>

These are similar to other languages. However, as in GEL it is simply an expression that must have some return value, these constructs will simply return the result of the last iteration or `NULL` if no iteration was done. In the boolean expression, `=` is translated into `==` just as for the `if` statement.

#### Циклы For

Syntax:

    for <identifier> = <from> to <to> do <body>
    for <identifier> = <from> to <to> by <increment> do <body>

Loop with identifier being set to all values from `<from>` to `<to>`, optionally using an increment other than 1. These are faster, nicer and more compact than the normal loops such as above, but less flexible. The identifier must be an identifier and can't be a dereference. The value of identifier is the last value of identifier, or `<from>` if body was never evaluated. The variable is guaranteed to be initialized after a loop, so you can safely use it. Also the `<from>`, `<to>` and `<increment>` must be non complex values. The `<to>` is not guaranteed to be hit, but will never be overshot, for example the following prints out odd numbers from 1 to 19:

    for i = 1 to 20 by 2 do print(i)

When one of the values is a floating point number, then the final check is done to within 2^-20 of the step size. That is, even if we overshoot by 2^-20 times the "by" above, we still execute the last iteration. This way

    for x = 0 to 1 by 0.1 do print(x)

does the expected even though adding 0.1 ten times becomes just slightly more than 1.0 due to the way that floating point numbers are stored in base 2 (there is no 0.1, the actual number stored is just ever so slightly bigger). This is not perfect but it handles the majority of the cases. If you want to avoid dealing with this issue, use actual rational numbers for example:

    for x = 0 to 1 by 1/10 do print(x)

This check is done only from version 1.0.16 onwards, so execution of your code may differ on older versions.

#### Циклы Foreach

Syntax:

    for <identifier> in <matrix> do <body>

For each element in the matrix, going row by row from left to right we execute the body with the identifier set to the current element. To print numbers 1,2,3 and 4 in this order you could do:

    for n in [1,2:3,4] do print(n)

If you wish to run through the rows and columns of a matrix, you can use the RowsOf and ColumnsOf functions, which return a vector of the rows or columns of the matrix. So,

    for n in RowsOf ([1,2:3,4]) do print(n)

will print out [1,2] and then [3,4].

#### Break и Continue

You can also use the `break` and `continue` commands in loops. The continue `continue` command will restart the current loop at its next iteration, while the `break` command exits the current loop.

    while(<expression1>) do (
      if(<expression2>) break
      else if(<expression3>) continue;
      <expression4>
    )

### Суммы и произведения

Syntax:

    sum <identifier> = <from> to <to> do <body>
    sum <identifier> = <from> to <to> by <increment> do <body>
    sum <identifier> in <matrix> do <body>
    prod <identifier> = <from> to <to> do <body>
    prod <identifier> = <from> to <to> by <increment> do <body>
    prod <identifier> in <matrix> do <body>

If you substitute `for` with `sum` or `prod`, then you will get a sum or a product instead of a `for` loop. Instead of returning the last value, these will return the sum or the product of the values respectively.

Если тело цикла не вычислялось (например, `sum i=1 to 0 do ...`), то `sum` возвращает 0, а `prod` возвращает 1.

For floating point numbers the same roundoff error protection is done as in the for loop. See .

### Операторы сравнения

В GEL поддерживаются следующие стандартные операторы сравнения, имеющие очевидное значение: `==`, `>=`, `<=`, `!=`, `<>`, `<`, `>`. Они возвращают `true` или `false`. Операторы `!=` и `<>` эквивалентны и означают «не равно». GEL также поддерживает оператор `<=>`, который возвращает -1, если левая сторона меньше, 0 при равенстве обеих сторон и 1, если левая сторона больше.

Normally `=` is translated to `==` if it happens to be somewhere where GEL is expecting a condition such as in the if condition. For example

    if a=b then c
    if a==b then c

are the same thing in GEL. However you should really use `==` or `:=` when you want to compare or assign respectively if you want your code to be easy to read and to avoid mistakes.

All the comparison operators (except for the `<=>` operator, which behaves normally), are not strictly binary operators, they can in fact be grouped in the normal mathematical way, e.g.: (`1<x<=y<5`) is a legal boolean expression and means just what it should, that is (1<x and x≤y and y<5)

To build up logical expressions use the words `not`, `and`, `or`, `xor`. The operators `or` and `and` are special beasts as they evaluate their arguments one by one, so the usual trick for conditional evaluation works here as well. For example, `1 or a=1` will not set `a=1` since the first argument was true.

### Глобальные переменные и область видимости переменных

GEL is a dynamically scoped language. We will explain what this means below. That is, normal variables and functions are dynamically scoped. The exception are parameter variables, which are always global.

Like most programming languages, GEL has different types of variables. Normally when a variable is defined in a function, it is visible from that function and from all functions that are called (all higher contexts). For example, suppose a function `f` defines a variable `a` and then calls function `g`. Then function `g` can reference `a`. But once `f` returns, the variable `a` goes out of scope. For example, the following code will print out 5. The function `g` cannot be called on the top level (outside `f` as `a` will not be defined).

    function f() = (a:=5; g());
    function g() = print(a);
    f();

If you define a variable inside a function it will override any variables defined in calling functions. For example, we modify the above code and write:

    function f() = (a:=5; g());
    function g() = print(a);
    a:=10;
    f();

This code will still print out 5. But if you call `g` outside of `f` then you will get a printout of 10. Note that setting `a` to 5 inside `f` does not change the value of `a` at the top (global) level, so if you now check the value of `a` it will still be 10.

Function arguments are exactly like variables defined inside the function, except that they are initialized with the value that was passed to the function. Other than this point, they are treated just like all other variables defined inside the function.

Functions are treated exactly like variables. Hence you can locally redefine functions. Normally (on the top level) you cannot redefine protected variables and functions. But locally you can do this. Consider the following session:

    genius> function f(x) = sin(x)^2
    = (`(x)=(sin(x)^2))
    genius> function f(x) = sin(x)^2
    = (`(x)=(sin(x)^2))
    genius> function g(x) = ((function sin(x)=x^10);f(x))
    = (`(x)=((sin:=(`(x)=(x^10)));f(x)))
    genius> g(10)
    = 1e20

Functions and variables defined at the top level are considered global. They are visible from anywhere. As we said the following function `f` will not change the value of `a` to 5.

    a=6;
    function f() = (a:=5);
    f();

Sometimes, however, it is necessary to set a global variable from inside a function. When this behavior is needed, use the `set` function. Passing a string or a quoted identifier to this function sets the variable globally (on the top level). For example, to set `a` to the value 3 you could call:

    set(`a,3)

or:

    set("a",3)

The `set` function always sets the toplevel global. There is no way to set a local variable in some function from a subroutine. If this is required, must use passing by reference.

See also the `SetElement` and `SetVElement` functions.

So to recap in a more technical language: Genius operates with different numbered contexts. The top level is the context 0 (zero). Whenever a function is entered, the context is raised, and when the function returns the context is lowered. A function or a variable is always visible from all higher numbered contexts. When a variable was defined in a lower numbered context, then setting this variable has the effect of creating a new local variable in the current context number and this variable will now be visible from all higher numbered contexts.

There are also true local variables that are not seen from anywhere but the current context. Also when returning functions by value it may reference variables not visible from higher context and this may be a problem. See the sections True Local Variables and Returning Functions.

### Parameter variables

As we said before, there exist special variables called parameters that exist in all scopes. To declare a parameter called `foo` with the initial value 1, we write

    parameter foo = 1

From then on, `foo` is a strictly global variable. Setting `foo` inside any function will modify the variable in all contexts, that is, functions do not have a private copy of parameters.

When you undefine a parameter using the `undefine` function, it stops being a parameter.

Some parameters are built-in and modify the behavior of genius.

### Returning

Normally a function is one or several expressions separated by a semicolon, and the value of the last expression is returned. This is fine for simple functions, but sometimes you do not want a function to return the last thing calculated. You may, for example, want to return from a middle of a function. In this case, you can use the `return` keyword. `return` takes one argument, which is the value to be returned.

Example:

    function f(x) = (
      y=1;
      while true do (
        if x>50 then return y;
        y=y+1;
        x=x+1
      )
    )

### References

It may be necessary for some functions to return more than one value. This may be accomplished by returning a vector of values, but many times it is convenient to use passing a reference to a variable. You pass a reference to a variable to a function, and the function will set the variable for you using a dereference. You do not have to use references only for this purpose, but this is their main use.

When using functions that return values through references in the argument list, just pass the variable name with an ampersand. For example the following code will compute an eigenvalue of a matrix `A` with initial eigenvector guess `x`, and store the computed eigenvector into the variable named `v`:

    RayleighQuotientIteration (A,x,0.001,100,&v)

The details of how references work and the syntax is similar to the C language. The operator `&` references a variable and `*` dereferences a variable. Both can only be applied to an identifier, so `**a` is not a legal expression in GEL.

References are best explained by an example:

    a=1;
    b=&a;
    *b=2;

now `a` contains 2. You can also reference functions:

    function f(x) = x+1;
    t=&f;
    *t(3)

gives us 4.

### Lvalues

An lvalue is the left hand side of an assignment. In other words, an lvalue is what you assign something to. Valid lvalues are:

`a`

  Identifier. Here we would be setting the variable of name `a`.

`*a`

  Dereference of an identifier. This will set whatever variable `a` points to.

`a@(<region>)`

  A region of a matrix. Here the region is specified normally as with the regular @() operator, and can be a single entry, or an entire region of the matrix.

Examples:

    a:=4
    *tmp := 89
    a@(1,1) := 5
    a@(4:8,3) := [1,2,3,4,5]'

Note that both `:=` and `=` can be used interchangeably. Except if the assignment appears in a condition. It is thus always safer to just use `:=` when you mean assignment, and `==` when you mean comparison.

## Advanced Programming with GEL

### Обработка ошибок

If you detect an error in your function, you can bail out of it. For normal errors, such as wrong types of arguments, you can fail to compute the function by adding the statement `bailout`. If something went really wrong and you want to completely kill the current computation, you can use `exception`.

For example if you want to check for arguments in your function. You could use the following code.

    function f(M) = (
      if not IsMatrix (M) then (
        error ("M not a matrix!");
        bailout
      );
      ...
    )

### Toplevel Syntax

The syntax is slightly different if you enter statements on the top level versus when they are inside parentheses or inside functions. On the top level, enter acts the same as if you press return on the command line. Therefore think of programs as just a sequence of lines as if they were entered on the command line. In particular, you do not need to enter the separator at the end of the line (unless it is part of several statements inside parentheses). When a statement does not end with a separator on the top level, the result is printed after being executed.

For example,

    function f(x)=x^2
    f(3)

will print first the result of setting a function (a representation of the function, in this case `(`(x)=(x^2))`) and then the expected 9. To avoid this, enter a separator after the function definition.

    function f(x)=x^2;
    f(3)

If you need to put a separator into your function then you have to surround with parenthesis. For example:

    function f(x)=(
      y=1;
      for j=1 to x do
        y = y+j;
      y^2
    );

The following code will produce an error when entered on the top level of a program, while it will work just fine in a function.

    if Something() then
      DoSomething()
    else
      DoSomethingElse()

The problem is that after Genius Mathematics Tool sees the end of line after the second line, it will decide that we have whole statement and it will execute it. After the execution is done, Genius Mathematics Tool will go on to the next line, it will see `else`, and it will produce a parsing error. To fix this, use parentheses. Genius Mathematics Tool will not be satisfied until it has found that all parentheses are closed.

    if Something() then (
      DoSomething()
    ) else (
      DoSomethingElse()
    )

### Returning Functions

It is possible to return functions as value. This way you can build functions that construct special purpose functions according to some parameters. The tricky bit is what variables does the function see. The way this works in GEL is that when a function returns another function, all identifiers referenced in the function body that went out of scope are prepended a private dictionary of the returned function. So the function will see all variables that were in scope when it was defined. For example, we define a function that returns a function that adds 5 to its argument.

    function f() = (
      k = 5;
      `(x) = (x+k)
    )

Notice that the function adds `k` to `x`. You could use this as follows.

    g = f();
    g(5)

And `g(5)` should return 10.

One thing to note is that the value of `k` that is used is the one that's in effect when the `f` returns. For example:

    function f() = (
      k := 5;
      function r(x) = (x+k);
      k := 10;
      r
    )

will return a function that adds 10 to its argument rather than 5. This is because the extra dictionary is created only when the context in which the function was defined ends, which is when the function `f` returns. This is consistent with how you would expect the function `r` to work inside the function `f` according to the rules of scope of variables in GEL. Only those variables are added to the extra dictionary that are in the context that just ended and no longer exists. Variables used in the function that are in still valid contexts will work as usual, using the current value of the variable. The only difference is with global variables and functions. All identifiers that referenced global variables at time of the function definition are not added to the private dictionary. This is to avoid much unnecessary work when returning functions and would rarely be a problem. For example, suppose that you delete the "k=5" from the function `f`, and at the top level you define `k` to be say 5. Then when you run `f`, the function `r` will not put `k` into the private dictionary because it was global (toplevel) at the time of definition of `r`.

Sometimes it is better to have more control over how variables are copied into the private dictionary. Since version 1.0.7, you can specify which variables are copied into the private dictionary by putting extra square brackets after the arguments with the list of variables to be copied separated by commas. If you do this, then variables are copied into the private dictionary at time of the function definition, and the private dictionary is not touched afterwards. For example

    function f() = (
      k := 5;
      function r(x) [k] = (x+k);
      k := 10;
      r
    )

will return a function that when called will add 5 to its argument. The local copy of `k` was created when the function was defined.

When you want the function to not have any private dictionary then put empty square brackets after the argument list. Then no private dictionary will be created at all. Doing this is good to increase efficiency when a private dictionary is not needed or when you want the function to lookup all variables as it sees them when called. For example suppose you want the function returned from `f` to see the value of `k` from the toplevel despite there being a local variable of the same name during definition. So the code

    function f() = (
      k := 5;
      function r(x) [] = (x+k);
      r
    );
    k := 10;
    g = f();
    g(10)

will return 20 and not 15, which would happen if `k` with a value of 5 was added to the private dictionary.

### True Local Variables

When passing functions into other functions, the normal scoping of variables might be undesired. For example:

    k := 10;
    function r(x) = (x+k);
    function f(g,x) = (
      k := 5;
      g(x)
    );
    f(r,1)

you probably want the function `r` when passed as `g` into `f` to see `k` as 10 rather than 5, so that the code returns 11 and not 6. However, as written, the function when executed will see the `k` that is equal to 5. There are two ways to solve this. One would be to have `r` get `k` in a private dictionary using the square bracket notation section Returning Functions.

But there is another solution. Since version 1.0.7 there are true local variables. These are variables that are visible only from the current context and not from any called functions. We could define `k` as a local variable in the function `f`. To do this add a `local` statement as the first statement in the function (it must always be the first statement in the function). You can also make any arguments be local variables as well. That is,

    function f(g,x) = (
      local g,x,k;
      k := 5;
      g(x)
    );

Then the code will work as expected and prints out 11. Note that the `local` statement initializes all the referenced variables (except for function arguments) to a `null`.

If all variables are to be created as locals you can just pass an asterisk instead of a list of variables. In this case the variables will not be initialized until they are actually set. So the following definition of `f` will also work:

    function f(g,x) = (
      local *;
      k := 5;
      g(x)
    );

It is good practice that all functions that take other functions as arguments use local variables. This way the passed function does not see implementation details and get confused.

### GEL Startup Procedure

First the program looks for the installed library file (the compiled version `lib.cgel`) in the installed directory, then it looks into the current directory, and then it tries to load an uncompiled file called `~/.geniusinit`.

If you ever change the library in its installed place, you’ll have to first compile it with `genius --compile loader.gel > lib.cgel`

### Загрузка программ

Sometimes you have a larger program you wrote into a file and want to read that file into Genius Mathematics Tool. In these situations, you have two options. You can keep the functions you use most inside the `~/.geniusinit` file. Or if you want to load up a file in a middle of a session (or from within another file), you can type `load <list of filenames>` at the prompt. This has to be done on the top level and not inside any function or whatnot, and it cannot be part of any expression. It also has a slightly different syntax than the rest of genius, more similar to a shell. You can enter the file in quotes. If you use the '' quotes, you will get exactly the string that you typed, if you use the "" quotes, special characters will be unescaped as they are for strings. Example:

    load program1.gel program2.gel
    load "Weird File Name With SPACES.gel"

There are also `cd`, `pwd` and `ls` commands built in. `cd` will take one argument, `ls` will take an argument that is like the glob in the UNIX shell (i.e., you can use wildcards). `pwd` takes no arguments. For example:

    cd directory_with_gel_programs
    ls *.gel

## Матрицы в GEL

Genius has support for vectors and matrices and possesses a sizable library of matrix manipulation and linear algebra functions.

### Ввод матриц

To enter matrices, you can use one of the following two syntaxes. You can either enter the matrix on one line, separating values by commas and rows by semicolons. Or you can enter each row on one line, separating values by commas. You can also just combine the two methods. So to enter a 3x3 matrix of numbers 1-9 you could do

    [1,2,3;4,5,6;7,8,9]

or

    [1, 2, 3
     4, 5, 6
     7, 8, 9]

Do not use both ';' and return at once on the same line though.

You can also use the matrix expansion functionality to enter matrices. For example you can do:

    a = [ 1, 2, 3
          4, 5, 6
          7, 8, 9]
    b = [ a,  10
          11, 12]

and you should get

    [1,   2,  3, 10
     4,   5,  6, 10
     7,   8,  9, 10
     11, 11, 11, 12]

similarly you can build matrices out of vectors and other stuff like that.

Another thing is that non-specified spots are initialized to 0, so

    [1, 2, 3
     4, 5
     6]

will end up being

    [1, 2, 3
     4, 5, 0
     6, 0, 0]

When matrices are evaluated, they are evaluated and traversed row-wise. This is just like the `M@(j)` operator, which traverses the matrix row-wise.

Be careful about using returns for expressions inside the `[ ]` brackets, as they have a slightly different meaning there. You will start a new row.

### Conjugate Transpose and Transpose Operator

You can conjugate transpose a matrix by using the `'` operator. That is the entry in the `i`th column and the `j`th row will be the complex conjugate of the entry in the `j`th column and the `i`th row of the original matrix. For example:

    [1,2,3]*[4,5,6]'

We transpose the second vector to make matrix multiplication possible. If you just want to transpose a matrix without conjugating it, you would use the `.'` operator. For example:

    [1,2,3]*[4,5,6i].'

Note that normal transpose, that is the `.'` operator, is much faster and will not create a new copy of the matrix in memory. The conjugate transpose does create a new copy unfortunately. It is recommended to always use the `.'` operator when working with real matrices and vectors.

### Линейная алгебра

Genius implements many useful linear algebra and matrix manipulation routines. See the Linear Algebra and Matrix Manipulation sections of the GEL function listing.

The linear algebra routines implemented in GEL do not currently come from a well tested numerical package, and thus should not be used for critical numerical computation. On the other hand, Genius implements very well many linear algebra operations with rational and integer coefficients. These are inherently exact and in fact will give you much better results than common double precision routines for linear algebra.

For example, it is pointless to compute the rank and nullspace of a floating point matrix since for all practical purposes, we need to consider the matrix as having some slight errors. You are likely to get a different result than you expect. The problem is that under a small perturbation every matrix is of full rank and invertible. If the matrix however is of rational numbers, then the rank and nullspace are always exact.

In general when Genius computes the basis of a certain vectorspace (for example with the `NullSpace`) it will give the basis as a matrix, in which the columns are the vectors of the basis. That is, when Genius talks of a linear subspace it means a matrix whose column space is the given linear subspace.

It should be noted that Genius can remember certain properties of a matrix. For example, it will remember that a matrix is in row reduced form. If many calls are made to functions that internally use row reduced form of the matrix, we can just row reduce the matrix beforehand once. Successive calls to `rref` will be very fast.

## Многочлены в GEL

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

### Использование многочленов

Currently polynomials in one variable are just horizontal vectors with value only nodes. The power of the term is the position in the vector, with the first position being 0. So,

    [1,2,3]

translates to a polynomial of

    1 + 2*x + 3*x^2

You can add, subtract and multiply polynomials using the `AddPoly`, `SubtractPoly`, and `MultiplyPoly` functions respectively. You can print a polynomial using the `PolyToString` function. For example,

    PolyToString([1,2,3],"y")

gives

    3*y^2 + 2*y + 1

You can also get a function representation of the polynomial so that you can evaluate it. This is done by using `PolyToFunction`, which returns an anonymous function.

    f = PolyToFunction([0,1,1])
    f(2)

It is also possible to find roots of polynomials of degrees 1 through 4 by using the function `PolynomialRoots`, which calls the appropriate formula function. Higher degree polynomials must be converted to functions and solved numerically using a function such as `FindRootBisection`, `FindRootFalsePosition`, `FindRootMullersMethod`, or `FindRootSecant`.

See in the function list for the rest of functions acting on polynomials.

## Теория множеств в GEL

Genius has some basic set theoretic functionality built in. Currently a set is just a vector (or a matrix). Every distinct object is treated as a different element.

### Using Sets

Just like vectors, objects in sets can include numbers, strings, `null`, matrices and vectors. It is planned in the future to have a dedicated type for sets, rather than using vectors. Note that floating point numbers are distinct from integers, even if they appear the same. That is, Genius will treat `0` and `0.0` as two distinct elements. The `null` is treated as an empty set.

To build a set out of a vector, use the `MakeSet` function. Currently, it will just return a new vector where every element is unique.

    genius> MakeSet([1,2,2,3])
    = [1, 2, 3]

Similarly there are functions `Union`, `Intersection`, `SetMinus`, which are rather self explanatory. For example:

    genius> Union([1,2,3], [1,2,4])
    = [1, 2, 4, 3]

Note that no order is guaranteed for the return values. If you wish to sort the vector you should use the `SortVector` function.

For testing membership, there are functions `IsIn` and `IsSubset`, which return a boolean value. For example:

    genius> IsIn (1, [0,1,2])
    = true

The input `IsIn(x,X)` is equivalent to `IsSubset([x],X)`. Note that since the empty set is a subset of every set, `IsSubset(null,X)` is always true.

## Список функций GEL

To get help on a specific function from the console type:

    help FunctionName

### Команды

help

      help

      help ИмяФункции

  Показывает справку (или справку по функции/команде).

load

      load "file.gel"

  Load a file into the interpreter. The file will execute as if it were typed onto the command line.

cd

      cd /каталог/имя

  Меняет рабочий каталог на `/каталог/имя`.

pwd

      pwd

  Выводит текущий рабочий каталог.

ls

      ls

  Показывает список файлов в текущем каталоге.

plugin

      plugin plugin_name

  Load a plugin. Plugin of that name must be installed on the system in the proper directory.

### Основные

AskButtons

      AskButtons (вопрос)

      AskButtons (вопрос, кнопка1, ...)

  Задаёт вопрос и предлагает пользователю список кнопок (или меню вариантов в текстовом режиме). Возвращает отсчитываемый с 1 индекс нажатой кнопки. То есть 1, если нажата первая кнопка, 2 — если нажата вторая и т.д. Если пользователь закрыл окно (или просто нажал Enter в текстовом режиме), то возвращает `null`. Выполнение программы останавливается, пока пользователь не ответит.

  Version 1.0.10 onwards.

AskString

      AskString (query)

      AskString (query, default)

  Asks a question and lets the user enter a string, which it then returns. If the user cancels or closes the window, then `null` is returned. The execution of the program is blocked until the user responds. If `default` is given, then it is pre-typed in for the user to just press enter on (version 1.0.6 onwards).

Compose

      Compose (f,g)

  Compose two functions and return a function that is the composition of `f` and `g`.

ComposePower

      ComposePower (f,n,x)

  Compose and execute a function with itself `n` times, passing `x` as argument. Returning `x` if `n` equals 0. Example:

      genius> function f(x) = x^2 ;
      genius> ComposePower (f,3,7)
      = 5764801
      genius> f(f(f(7)))
      = 5764801

Evaluate

      Evaluate (str)

  Parses and evaluates a string.

GetCurrentModulo

      GetCurrentModulo

  Get current modulo from the context outside the function. That is, if outside of the function was executed in modulo (using `mod`) then this returns what this modulo was. Normally the body of the function called is not executed in modular arithmetic, and this builtin function makes it possible to make GEL functions aware of modular arithmetic.

Identity

      Identity (x)

  Identity function, returns its argument. It is equivalent to `function Identity(x)=x`.

IntegerFromBoolean

      IntegerFromBoolean (bval)

  Преобразует логическое значение в целое число (0 для `false` или 1 для `true`). `bval` может также быть числом, в этом случае ненулевое значение интерпретируется как `true`, а нулевое — как `false`.

IsBoolean

      IsBoolean (arg)

  Проверяет, является аргумент логическим значением (а не числом).

IsDefined

      IsDefined (id)

  Check if an id is defined. You should pass a string or and identifier. If you pass a matrix, each entry will be evaluated separately and the matrix should contain strings or identifiers.

IsFunction

      IsFunction (arg)

  Проверяет, является ли аргумент функцией.

IsFunctionOrIdentifier

      IsFunctionOrIdentifier (arg)

  Check if argument is a function or an identifier.

IsFunctionRef

      IsFunctionRef (arg)

  Check if argument is a function reference. This includes variable references.

IsMatrix

      IsMatrix (arg)

  Проверяет, является ли аргумент матрицей. Хотя `null` иногда используют вместо пустой матрицы, функция `IsMatrix` не считает `null` матрицей.

IsNull

      IsNull (arg)

  Проверяет, имеет ли аргумент значение `null`.

IsString

      IsString (arg)

  Проверяет, является ли аргумент текстовой строкой.

IsValue

      IsValue (arg)

  Проверяет, является ли аргумент числом.

Parse

      Parse (str)

  Parses but does not evaluate a string. Note that certain pre-computation is done during the parsing stage.

SetFunctionFlags

      SetFunctionFlags (id,flags...)

  Set flags for a function, currently `"PropagateMod"` and `"NoModuloArguments"`. If `"PropagateMod"` is set, then the body of the function is evaluated in modular arithmetic when the function is called inside a block that was evaluated using modular arithmetic (using `mod`). If `"NoModuloArguments"`, then the arguments of the function are never evaluated using modular arithmetic.

SetHelp

      SetHelp (id,category,desc)

  Set the category and help description line for a function.

SetHelpAlias

      SetHelpAlias (id,alias)

  Sets up a help alias.

chdir

      chdir (dir)

  Изменяет текущий каталог. То же, что и `cd`.

CurrentTime

      CurrentTime

  Возвращает текущее время UNIX с точностью до микросекунд в виде числа с плавающей точкой. То есть возвращает число секунд с 1 января 1970 г.

  Version 1.0.15 onwards.

display

      display (str,expr)

  Display a string and an expression with a colon to separate them.

DisplayVariables

      DisplayVariables (var1,var2,...)

  Display set of variables. The variables can be given as strings or identifiers. For example:

      DisplayVariables(`x,`y,`z)

  If called without arguments (must supply empty argument list) as

      DisplayVariables()

  then all variables are printed including a stacktrace similar to Show user variables in the graphical version.

  Version 1.0.18 onwards.

error

      error (str)

  Выводит строку в поток ошибок (на консоль).

exit

      exit

  Псевдоним: `quit`

  Завершает работу программы.

false

      false

  Aliases: `False` `FALSE`

  Логическое значение `false` (ложь).

manual

      manual

  Показывает руководство пользователя.

print

      print (str)

  Выводит выражение и выполняет переход на новую строку. Аргумент `str` может быть любым выражением. Он преобразуется в строку перед выводом.

printn

      printn (str)

  Выводит выражение без перехода на новую строку. Аргумент `str` может быть любым выражением. Он преобразуется в строку перед выводом.

PrintTable

      PrintTable (f,v)

  Print a table of values for a function. The values are in the vector `v`. You can use the vector building notation as follows:

      PrintTable (f,[0:10])

  If `v` is a positive integer, then the table of integers from 1 up to and including v will be used.

  Version 1.0.18 onwards.

protect

      protect (id)

  Protect a variable from being modified. This is used on the internal GEL functions to avoid them being accidentally overridden.

ProtectAll

      ProtectAll ()

  Protect all currently defined variables, parameters and functions from being modified. This is used on the internal GEL functions to avoid them being accidentally overridden. Normally Genius Mathematics Tool considers unprotected variables as user defined.

  Version 1.0.7 onwards.

set

      set (id,val)

  Set a global variable. The `id` can be either a string or a quoted identifier. For example:

      set(`x,1)

  will set the global variable `x` to the value 1.

  The function returns the `val`, to be usable in chaining.

SetElement

      SetElement (id,row,col,val)

  Set an element of a global variable which is a matrix. The `id` can be either a string or a quoted identifier. For example:

      SetElement(`x,2,3,1)

  will set the second row third column element of the global variable `x` to the value 1. If no global variable of the name exists, or if it is set to something that's not a matrix, a new zero matrix of appropriate size will be created.

  The `row` and `col` can also be ranges, and the semantics are the same as for regular setting of the elements with an equals sign.

  The function returns the `val`, to be usable in chaining.

  Available from 1.0.18 onwards.

SetVElement

      SetElement (id,elt,val)

  Set an element of a global variable which is a vector. The `id` can be either a string or a quoted identifier. For example:

      SetElement(`x,2,1)

  will set the second element of the global vector variable `x` to the value 1. If no global variable of the name exists, or if it is set to something that's not a vector (matrix), a new zero row vector of appropriate size will be created.

  The `elt` can also be a range, and the semantics are the same as for regular setting of the elements with an equals sign.

  The function returns the `val`, to be usable in chaining.

  Available from 1.0.18 onwards.

string

      string (s)

  Преобразует аргумент любого типа в строку.

true

      true

  Aliases: `True` `TRUE`

  Логическое значение `true` (истина).

undefine

      undefine (id)

  Alias: `Undefine`

  Undefine a variable. This includes locals and globals, every value on all context levels is wiped. This function should really not be used on local variables. A vector of identifiers can also be passed to undefine several variables.

UndefineAll

      UndefineAll ()

  Undefine all unprotected global variables (including functions and parameters). Normally Genius Mathematics Tool considers protected variables as system defined functions and variables. Note that `UndefineAll` only removes the global definition of symbols not local ones, so that it may be run from inside other functions safely.

  Version 1.0.7 onwards.

unprotect

      unprotect (id)

  Unprotect a variable from being modified.

UserVariables

      UserVariables ()

  Возвращает вектор идентификаторов определённых пользователем (незащищённых) глобальных переменных.

  Version 1.0.7 onwards.

wait

      wait (secs)

  Waits a specified number of seconds. `secs` must be non-negative. Zero is accepted and nothing happens in this case, except possibly user interface events are processed.

  Since version 1.0.18, `secs` can be a noninteger number, so `wait(0.1)` will wait for one tenth of a second.

version

      version

  Returns the version of Genius as a horizontal 3-vector with major version first, then minor version and finally the patch level.

warranty

      warranty

  Gives the warranty information.

### Параметры

ChopTolerance

      ChopTolerance = number

  Tolerance of the `Chop` function.

ContinuousNumberOfTries

      ContinuousNumberOfTries = number

  How many iterations to try to find the limit for continuity and limits.

ContinuousSFS

      ContinuousSFS = number

  How many successive steps to be within tolerance for calculation of continuity.

ContinuousTolerance

      ContinuousTolerance = number

  Tolerance for continuity of functions and for calculating the limit.

DerivativeNumberOfTries

      DerivativeNumberOfTries = number

  How many iterations to try to find the limit for derivative.

DerivativeSFS

      DerivativeSFS = number

  How many successive steps to be within tolerance for calculation of derivative.

DerivativeTolerance

      DerivativeTolerance = number

  Tolerance for calculating the derivatives of functions.

ErrorFunctionTolerance

      ErrorFunctionTolerance = number

  Tolerance of the `ErrorFunction`.

FloatPrecision

      FloatPrecision = число

  Точность чисел с плавающей точкой.

FullExpressions

      FullExpressions = логическое значение

  Выводить полные выражения, даже если они превышают длину строки.

GaussDistributionTolerance

      GaussDistributionTolerance = number

  Tolerance of the `GaussDistribution` function.

IntegerOutputBase

      IntegerOutputBase = number

  Integer output base.

IsPrimeMillerRabinReps

      IsPrimeMillerRabinReps = number

  Number of extra Miller-Rabin tests to run on a number before declaring it a prime in `IsPrime`.

LinePlotDrawLegends

      LinePlotDrawLegends = true

  Tells genius to draw the legends for line plotting functions such as `LinePlot`.

LinePlotDrawAxisLabels

      LinePlotDrawAxisLabels = true

  Tells genius to draw the axis labels for line plotting functions such as `LinePlot`.

  Version 1.0.16 onwards.

LinePlotVariableNames

      LinePlotVariableNames = ["x","y","z","t"]

  Tells genius which variable names are used as default names for line plotting functions such as `LinePlot` and friends.

  Version 1.0.10 onwards.

LinePlotWindow

      LinePlotWindow = [x1,x2,y1,y2]

  Sets the limits for line plotting functions such as `LinePlot`.

MaxDigits

      MaxDigits = number

  Maximum digits to display.

MaxErrors

      MaxErrors = number

  Maximum errors to display.

MixedFractions

      MixedFractions = логическое значение

  Если true, выводятся смешанные дроби.

NumericalIntegralFunction

      NumericalIntegralFunction = function

  The function used for numerical integration in `NumericalIntegral`.

NumericalIntegralSteps

      NumericalIntegralSteps = number

  Steps to perform in `NumericalIntegral`.

OutputChopExponent

      OutputChopExponent = number

  When another number in the object being printed (a matrix or a value) is greater than 10-OutputChopWhenExponent, and the number being printed is less than 10-OutputChopExponent, then display `0.0` instead of the number.

  Output is never chopped if `OutputChopExponent` is zero. It must be a non-negative integer.

  If you want output always chopped according to `OutputChopExponent`, then set `OutputChopWhenExponent`, to something greater than or equal to `OutputChopExponent`.

OutputChopWhenExponent

      OutputChopWhenExponent = number

  When to chop output. See `OutputChopExponent`.

OutputStyle

      OutputStyle = строка

  Стиль вывода, может быть `normal`, `latex`, `mathml` или `troff`.

  This affects mostly how matrices and fractions are printed out and is useful for pasting into documents. For example you can set this to the latex by:

      OutputStyle = "latex"

ResultsAsFloats

      ResultsAsFloats = boolean

  Convert all results to floats before printing.

ScientificNotation

      ScientificNotation = boolean

  Use scientific notation.

SlopefieldTicks

      SlopefieldTicks = [vertical,horizontal]

  Sets the number of vertical and horizontal ticks in a slopefield plot. (See `SlopefieldPlot`).

  Version 1.0.10 onwards.

SumProductNumberOfTries

      SumProductNumberOfTries = number

  How many iterations to try for `InfiniteSum` and `InfiniteProduct`.

SumProductSFS

      SumProductSFS = number

  How many successive steps to be within tolerance for `InfiniteSum` and `InfiniteProduct`.

SumProductTolerance

      SumProductTolerance = number

  Tolerance for `InfiniteSum` and `InfiniteProduct`.

SurfacePlotDrawLegends

      SurfacePlotDrawLegends = true

  Tells genius to draw the legends for surface plotting functions such as `SurfacePlot`.

  Version 1.0.16 onwards.

SurfacePlotVariableNames

      SurfacePlotVariableNames = ["x","y","z"]

  Tells genius which variable names are used as default names for surface plotting functions using `SurfacePlot`. Note that the `z` does not refer to the dependent (vertical) axis, but to the independent complex variable `z=x+iy`.

  Version 1.0.10 onwards.

SurfacePlotWindow

      SurfacePlotWindow = [x1,x2,y1,y2,z1,z2]

  Sets the limits for surface plotting (See `SurfacePlot`).

VectorfieldNormalized

      VectorfieldNormalized = true

  Should the vectorfield plotting have normalized arrow length. If true, vector fields will only show direction and not magnitude. (See `VectorfieldPlot`).

VectorfieldTicks

      VectorfieldTicks = [vertical,horizontal]

  Sets the number of vertical and horizontal ticks in a vectorfield plot. (See `VectorfieldPlot`).

  Version 1.0.10 onwards.

### Константы

CatalanConstant

      CatalanConstant

  Catalan's Constant, approximately 0.915... It is defined to be the series where terms are `(-1^k)/((2*k+1)^2)`, where `k` ranges from 0 to infinity.

  See Wikipedia or Mathworld for more information.

EulerConstant

      EulerConstant

  Aliases: `gamma`

  Euler's constant gamma. Sometimes called the Euler-Mascheroni constant.

  See Wikipedia or Planetmath or Mathworld for more information.

GoldenRatio

      GoldenRatio

  The Golden Ratio.

  See Wikipedia or Planetmath or Mathworld for more information.

Gravity

      Gravity

  Free fall acceleration at sea level in meters per second squared. This is the standard gravity constant 9.80665. The gravity in your particular neck of the woods might be different due to different altitude and the fact that the earth is not perfectly round and uniform.

  See Wikipedia for more information.

e

      e

  The base of the natural logarithm. `e^x` is the exponential function `exp`. It is approximately 2.71828182846... This number is sometimes called Euler's number, although there are several numbers that are also called Euler's. An example is the gamma constant: `EulerConstant`.

  See Wikipedia or Planetmath or Mathworld for more information.

pi

      pi

  Число «пи» — отношение длины окружности к её диаметру. Значение приблизительно равно 3.14159265359...

  See Wikipedia or Planetmath or Mathworld for more information.

### Числовые

AbsoluteValue

      AbsoluteValue (x)

  Синонимы: `abs`

  Absolute value of a number and if `x` is a complex value the modulus of `x`. I.e. this the distance of `x` to the origin. This is equivalent to `|x|`.

  See Wikipedia, Planetmath (absolute value), Planetmath (modulus), Mathworld (absolute value) or Mathworld (complex modulus) for more information.

Chop

      Chop (x)

  Заменяет очень малое число нулём.

ComplexConjugate

      ComplexConjugate (z)

  Aliases: `conj` `Conj`

  Calculates the complex conjugate of the complex number `z`. If `z` is a vector or matrix, all its elements are conjugated.

  See Wikipedia for more information.

Denominator

      Denominator (x)

  Возвращает знаменатель рационального числа.

  See Wikipedia for more information.

FractionalPart

      FractionalPart (x)

  Возвращает дробную часть числа.

  See Wikipedia for more information.

Im

      Im (z)

  Синонимы: `ImaginaryPart`

  Get the imaginary part of a complex number. For example `Re(3+4i)` yields 4.

  See Wikipedia for more information.

IntegerQuotient

      IntegerQuotient (m,n)

  Деление без остатка.

IsComplex

      IsComplex (num)

  Check if argument is a complex (non-real) number. Do note that we really mean nonreal number. That is, `IsComplex(3)` yields false, while `IsComplex(3-1i)` yields true.

IsComplexRational

      IsComplexRational (num)

  Check if argument is a possibly complex rational number. That is, if both real and imaginary parts are given as rational numbers. Of course rational simply means "not stored as a floating point number."

IsFloat

      IsFloat (num)

  Check if argument is a real floating point number (non-complex).

IsGaussInteger

      IsGaussInteger (num)

  Aliases: `IsComplexInteger`

  Check if argument is a possibly complex integer. That is a complex integer is a number of the form `n+1i*m` where `n` and `m` are integers.

IsInteger

      IsInteger (num)

  Проверяет, является ли аргумент целым числом (не комплексным).

IsNonNegativeInteger

      IsNonNegativeInteger (num)

  Check if argument is a non-negative real integer. That is, either a positive integer or zero.

IsPositiveInteger

      IsPositiveInteger (num)

  Синонимы: `IsNaturalNumber`

  Проверяет, является ли аргумент положительным действительным целым числом. Обратите внимание, что мы придерживаемся соглашения о том, что 0 не является натуральным числом.

IsRational

      IsRational (num)

  Проверяет, является ли аргумент рациональным числом (не комплексным). Разумеется, «рациональное» означает просто «не хранящееся в виде числа с плавающей точкой».

IsReal

      IsReal (num)

  Проверяет, является ли аргумент действительным числом.

Numerator

      Numerator (x)

  Возвращает числитель рационального числа.

  See Wikipedia for more information.

Re

      Re (z)

  Синонимы: `RealPart`

  Get the real part of a complex number. For example `Re(3+4i)` yields 3.

  See Wikipedia for more information.

Sign

      Sign (x)

  Синонимы: `sign`

  Возвращает знак числа. То есть, возвращает `-1`, если значение отрицательно, `0`, если рано нулю и `1`, если значение положительно. Если `x` — комплексное число, то `Sign` возвращает направление на числовой оси (положительное или отрицательное) или 0.

ceil

      ceil (x)

  Синонимы: `Ceiling`

  Get the lowest integer more than or equal to `n`. Examples:

      genius> ceil(1.1)
      = 2
      genius> ceil(-1.1)
      = -1

  Note that you should be careful and notice that floating point numbers are stored in binary and so may not be what you expect. For example `ceil(420/4.2)` returns 101 instead of the expected 100. This is because 4.2 is actually very slightly less than 4.2. Use rational representation `42/10` if you want exact arithmetic.

exp

      exp (x)

  Экспоненциальная функция. Это функция `e^x`, где `e` — основание натурального логарифма.

  See Wikipedia or Planetmath or Mathworld for more information.

float

      float (x)

  Возвращает представление числа `x` в виде числа с плавающей точкой.

floor

      floor (x)

  Синонимы: `Floor`

  Возвращает наибольшее целое число, которое меньше или равно `n`.

ln

      ln (x)

  Натуральный логарифм (логарифм по основанию `e`).

  See Wikipedia or Planetmath or Mathworld for more information.

log

      log (x)

      log (x,b)

  Logarithm of `x` base `b` (calls `DiscreteLog` if in modulo mode), if base is not given, `e` is used.

log10

      log10 (x)

  Логарифм `x` по основанию 10.

log2

      log2 (x)

  Синоним: `lg`

  Логарифм `x` по основанию 2.

max

      max (a,args...)

  Aliases: `Max` `Maximum`

  Возвращает максимальный из аргументов или элементов матрицы.

min

      min (a,args...)

  Aliases: `Min` `Minimum`

  Возвращает минимальный из аргументов или элементов матрицы.

rand

      rand (size...)

  Генерирует случайное число с плавающей точкой в диапазоне `[0,1)`. Если задан аргумент size, то может возвращать матрицу (если указано два числа) или вектор (если указано одно число) заданной размерности.

randint

      randint (max,size...)

  Generate random integer in the range `[0,max)`. If size is given then a matrix (if two numbers are specified) or vector (if one number is specified) of the given size returned. For example,

      genius> randint(4)
      = 3
      genius> randint(4,2)
      =
      [0      1]
      genius> randint(4,2,3)
      =
      [2      2       1
       0      0       3]

round

      round (x)

  Синонимы: `Round`

  Округляет число.

sqrt

      sqrt (x)

  Синонимы: `SquareRoot`

  The square root. When operating modulo some integer will return either a `null` or a vector of the square roots. Examples:

      genius> sqrt(2)
      = 1.41421356237
      genius> sqrt(-1)
      = 1i
      genius> sqrt(4) mod 7
      =
      [2      5]
      genius> 2*2 mod 7
      = 4

  See Wikipedia or Planetmath for more information.

trunc

      trunc (x)

  Aliases: `Truncate` `IntegerPart`

  Усекает число до целого (возвращает целую часть).

### Тригонометрические

acos

      acos (x)

  Синонимы: `arccos`

  Функция arccos (арккосинус, обратный косинус).

acosh

      acosh (x)

  Синонимы: `arccosh`

  Функция arccosh (обратный гиперболический косинус).

acot

      acot (x)

  Синонимы: `arccot`

  Фунция arccot (арккотангенс, обратный котангенс).

acoth

      acoth (x)

  Синонимы: `arccoth`

  Функция arccoth (обратный гиперболический котангенс).

acsc

      acsc (x)

  Синонимы: `arccsc`

  Обратный косеканс.

acsch

      acsch (x)

  Синонимы: `arccsch`

  Обратный гиперболический косеканс.

asec

      asec (x)

  Синонимы: `arcsec`

  Обратный секанс.

asech

      asech (x)

  Синонимы: `arcsech`

  Обратный гиперболический секанс.

asin

      asin (x)

  Синонимы: `arcsin`

  Функция arcsin (арксинус, обратный синус).

asinh

      asinh (x)

  Синонимы: `arcsinh`

  Фунция arcsinh (обратный гиперболический синус).

atan

      atan (x)

  Синонимы: `arctan`

  Вычисляет функцию arctan (арктангенс, обратный тангенс).

  See Wikipedia or Mathworld for more information.

atanh

      atanh (x)

  Синонимы: `arctanh`

  Функция arctanh (обратный гиперболический тангенс).

atan2

      atan2 (y, x)

  Синонимы: `arctan2`

  Calculates the arctan2 function. If `x>0` then it returns `atan(y/x)`. If `x<0` then it returns `sign(y) * (pi - atan(|y/x|)`. When `x=0` it returns `sign(y) * pi/2`. `atan2(0,0)` returns 0 rather than failing.

  See Wikipedia or Mathworld for more information.

cos

      cos (x)

  Вычисляет косинус.

  See Wikipedia or Planetmath for more information.

cosh

      cosh (x)

  Вычисляет гиперболический косинус.

  See Wikipedia or Planetmath for more information.

cot

      cot (x)

  Вычисляет котангенс.

  See Wikipedia or Planetmath for more information.

coth

      coth (x)

  Вычисляет гиперболический котангенс.

  See Wikipedia or Planetmath for more information.

csc

      csc (x)

  Вычисляет косеканс.

  See Wikipedia or Planetmath for more information.

csch

      csch (x)

  Вычисляет гиперболический косеканс.

  See Wikipedia or Planetmath for more information.

sec

      sec (x)

  Вычисляет секанс.

  See Wikipedia or Planetmath for more information.

sech

      sech (x)

  Вычисляет гиперболический секанс.

  See Wikipedia or Planetmath for more information.

sin

      sin (x)

  Вычисляет синус.

  See Wikipedia or Planetmath for more information.

sinh

      sinh (x)

  Вычисляет гиперболический синус.

  See Wikipedia or Planetmath for more information.

tan

      tan (x)

  Вычисляет тангенс.

  See Wikipedia or Planetmath for more information.

tanh

      tanh (x)

  Вычисляет гиперболический тангенс.

  See Wikipedia or Planetmath for more information.

### Теория чисел

AreRelativelyPrime

      AreRelativelyPrime (a,b)

  Are the real integers `a` and `b` relatively prime? Returns `true` or `false`.

  See Wikipedia or Planetmath or Mathworld for more information.

BernoulliNumber

      BernoulliNumber (n)

  Return the `n`th Bernoulli number.

  See Wikipedia or Mathworld for more information.

ChineseRemainder

      ChineseRemainder (a,m)

  Aliases: `CRT`

  Find the `x` that solves the system given by the vector `a` and modulo the elements of `m`, using the Chinese Remainder Theorem.

  See Wikipedia or Planetmath or Mathworld for more information.

CombineFactorizations

      CombineFactorizations (a,b)

  Given two factorizations, give the factorization of the product.

  See Factorize.

ConvertFromBase

      ConvertFromBase (v,b)

  Convert a vector of values indicating powers of b to a number.

ConvertToBase

      ConvertToBase (n,b)

  Convert a number to a vector of powers for elements in base `b`.

DiscreteLog

      DiscreteLog (n,b,q)

  Find discrete log of `n` base `b` in Fq, the finite field of order `q`, where `q` is a prime, using the Silver-Pohlig-Hellman algorithm.

  See Wikipedia, Planetmath, or Mathworld for more information.

Divides

      Divides (m,n)

  Проверяет делимость (делится ли `n` на `m`).

EulerPhi

      EulerPhi (n)

  Compute the Euler phi function for `n`, that is the number of integers between 1 and `n` relatively prime to `n`.

  See Wikipedia, Planetmath, or Mathworld for more information.

ExactDivision

      ExactDivision (n,d)

  Return `n/d` but only if `d` divides `n`. If `d` does not divide `n` then this function returns garbage. This is a lot faster for very large numbers than the operation `n/d`, but it is only useful if you know that the division is exact.

Factorize

      Factorize (n)

  Return factorization of a number as a matrix. The first row is the primes in the factorization (including 1) and the second row are the powers. So for example:

      genius> Factorize(11*11*13)
      =
      [1      11      13
       1      2       1]

  See Wikipedia for more information.

Factors

      Factors (n)

  Return all factors of `n` in a vector. This includes all the non-prime factors as well. It includes 1 and the number itself. So to print all the perfect numbers (those that are sums of their factors) up to the number 1000 you could do (this is clearly very inefficient)

      for n=1 to 1000 do (
          if MatrixSum (Factors(n)) == 2*n then
              print(n)
      )

FermatFactorization

      FermatFactorization (n,tries)

  Attempt Fermat factorization of `n` into `(t-s)*(t+s)`, returns `t` and `s` as a vector if possible, `null` otherwise. `tries` specifies the number of tries before giving up.

  This is a fairly good factorization if your number is the product of two factors that are very close to each other.

  See Wikipedia for more information.

FindPrimitiveElementMod

      FindPrimitiveElementMod (q)

  Find the first primitive element in Fq, the finite group of order `q`. Of course `q` must be a prime.

FindRandomPrimitiveElementMod

      FindRandomPrimitiveElementMod (q)

  Find a random primitive element in Fq, the finite group of order `q` (q must be a prime).

IndexCalculus

      IndexCalculus (n,b,q,S)

  Compute discrete log base `b` of n in Fq, the finite group of order `q` (`q` a prime), using the factor base `S`. `S` should be a column of primes possibly with second column precalculated by `IndexCalculusPrecalculation`.

IndexCalculusPrecalculation

      IndexCalculusPrecalculation (b,q,S)

  Run the precalculation step of `IndexCalculus` for logarithms base `b` in Fq, the finite group of order `q` (`q` a prime), for the factor base `S` (where `S` is a column vector of primes). The logs will be precalculated and returned in the second column.

IsEven

      IsEven (n)

  Проверяет, является ли целое число чётным.

IsMersennePrimeExponent

      IsMersennePrimeExponent (p)

  Tests if a positive integer `p` is a Mersenne prime exponent. That is if 2p-1 is a prime. It does this by looking it up in a table of known values, which is relatively short. See also MersennePrimeExponents and LucasLehmer.

  See Wikipedia, Planetmath, Mathworld or GIMPS for more information.

IsNthPower

      IsNthPower (m,n)

  Tests if a rational number `m` is a perfect `n`th power. See also IsPerfectPower and IsPerfectSquare.

IsOdd

      IsOdd (n)

  Проверяет, является ли целое число нечётным.

IsPerfectPower

      IsPerfectPower (n)

  Check an integer for being any perfect power, ab.

IsPerfectSquare

      IsPerfectSquare (n)

  Check an integer for being a perfect square of an integer. The number must be an integer. Negative integers are never perfect squares of integers.

IsPrime

      IsPrime (n)

  Tests primality of integers, for numbers less than 2.5e10 the answer is deterministic (if Riemann hypothesis is true). For numbers larger, the probability of a false positive depends on `IsPrimeMillerRabinReps`. That is the probability of false positive is 1/4 to the power `IsPrimeMillerRabinReps`. The default value of 22 yields a probability of about 5.7e-14.

  If `false` is returned, you can be sure that the number is a composite. If you want to be absolutely sure that you have a prime you can use `MillerRabinTestSure` but it may take a lot longer.

  See Planetmath or Mathworld for more information.

IsPrimitiveMod

      IsPrimitiveMod (g,q)

  Check if `g` is primitive in Fq, the finite group of order `q`, where `q` is a prime. If `q` is not prime results are bogus.

IsPrimitiveModWithPrimeFactors

      IsPrimitiveModWithPrimeFactors (g,q,f)

  Check if `g` is primitive in Fq, the finite group of order `q`, where `q` is a prime and `f` is a vector of prime factors of `q`-1. If `q` is not prime results are bogus.

IsPseudoprime

      IsPseudoprime (n,b)

  If `n` is a pseudoprime base `b` but not a prime, that is if `b^(n-1) == 1 mod n`. This calls the `PseudoprimeTest`

IsStrongPseudoprime

      IsStrongPseudoprime (n,b)

  Test if `n` is a strong pseudoprime to base `b` but not a prime.

Jacobi

      Jacobi (a,b)

  Синонимы: `JacobiSymbol`

  Вычисляет символ Якоби (a/b) (b должно быть нечётным).

JacobiKronecker

      JacobiKronecker (a,b)

  Синонимы: `JacobiKroneckerSymbol`

  Вычисляет символ Якоби (a/b) с дополнением Кронекера (a/2)=(2/a), если нечётное или (a/2)=0, если чётное.

LeastAbsoluteResidue

      LeastAbsoluteResidue (a,n)

  Return the residue of `a` mod `n` with the least absolute value (in the interval -n/2 to n/2).

Legendre

      Legendre (a,p)

  Aliases: `LegendreSymbol`

  Calculate the Legendre symbol (a/p).

  See Planetmath or Mathworld for more information.

LucasLehmer

      LucasLehmer (p)

  Test if 2p-1 is a Mersenne prime using the Lucas-Lehmer test. See also MersennePrimeExponents and IsMersennePrimeExponent.

  See Wikipedia, Planetmath, or Mathworld for more information.

LucasNumber

      LucasNumber (n)

  Returns the `n`th Lucas number.

  See Wikipedia, Planetmath, or Mathworld for more information.

MaximalPrimePowerFactors

      MaximalPrimePowerFactors (n)

  Return all maximal prime power factors of a number.

MersennePrimeExponents

      MersennePrimeExponents

  A vector of known Mersenne prime exponents, that is a list of positive integers `p` such that 2p-1 is a prime. See also IsMersennePrimeExponent and LucasLehmer.

  See Wikipedia, Planetmath, Mathworld or GIMPS for more information.

MillerRabinTest

      MillerRabinTest (n,reps)

  Use the Miller-Rabin primality test on `n`, `reps` number of times. The probability of false positive is `(1/4)^reps`. It is probably usually better to use `IsPrime` since that is faster and better on smaller integers.

  See Wikipedia or Planetmath or Mathworld for more information.

MillerRabinTestSure

      MillerRabinTestSure (n)

  Use the Miller-Rabin primality test on `n` with enough bases that assuming the Generalized Riemann Hypothesis the result is deterministic.

  See Wikipedia, Planetmath, or Mathworld for more information.

ModInvert

      ModInvert (n,m)

  Returns inverse of n mod m.

  See Mathworld for more information.

MoebiusMu

      MoebiusMu (n)

  Return the Moebius mu function evaluated in `n`. That is, it returns 0 if `n` is not a product of distinct primes and `(-1)^k` if it is a product of `k` distinct primes.

  See Planetmath or Mathworld for more information.

NextPrime

      NextPrime (n)

  Returns the least prime greater than `n`. Negatives of primes are considered prime and so to get the previous prime you can use `-NextPrime(-n)`.

  This function uses the GMPs `mpz_nextprime`, which in turn uses the probabilistic Miller-Rabin test (See also `MillerRabinTest`). The probability of false positive is not tunable, but is low enough for all practical purposes.

  See Planetmath or Mathworld for more information.

PadicValuation

      PadicValuation (n,p)

  Returns the p-adic valuation (number of trailing zeros in base `p`).

  See Wikipedia or Planetmath for more information.

PowerMod

      PowerMod (a,b,m)

  Compute `a^b mod m`. The `b`'s power of `a` modulo `m`. It is not necessary to use this function as it is automatically used in modulo mode. Hence `a^b mod m` is just as fast.

Prime

      Prime (n)

  Aliases: `prime`

  Return the `n`th prime (up to a limit).

  See Planetmath or Mathworld for more information.

PrimeFactors

      PrimeFactors (n)

  Return all prime factors of a number as a vector.

  See Wikipedia or Mathworld for more information.

PseudoprimeTest

      PseudoprimeTest (n,b)

  Pseudoprime test, returns `true` if and only if `b^(n-1) == 1 mod n`

  See Planetmath or Mathworld for more information.

RemoveFactor

      RemoveFactor (n,m)

  Removes all instances of the factor `m` from the number `n`. That is divides by the largest power of `m`, that divides `n`.

  See Planetmath or Mathworld for more information.

SilverPohligHellmanWithFactorization

      SilverPohligHellmanWithFactorization (n,b,q,f)

  Find discrete log of `n` base `b` in Fq, the finite group of order `q`, where `q` is a prime using the Silver-Pohlig-Hellman algorithm, given `f` being the factorization of `q`-1.

SqrtModPrime

      SqrtModPrime (n,p)

  Find square root of `n` modulo `p` (where `p` is a prime). Null is returned if not a quadratic residue.

  See Planetmath or Mathworld for more information.

StrongPseudoprimeTest

      StrongPseudoprimeTest (n,b)

  Run the strong pseudoprime test base `b` on `n`.

  See Wikipedia, Planetmath, or Mathworld for more information.

gcd

      gcd (a,args...)

  Aliases: `GCD`

  Greatest common divisor of integers. You can enter as many integers as you want in the argument list, or you can give a vector or a matrix of integers. If you give more than one matrix of the same size then GCD is done element by element.

  See Wikipedia, Planetmath, or Mathworld for more information.

lcm

      lcm (a,args...)

  Aliases: `LCM`

  Least common multiplier of integers. You can enter as many integers as you want in the argument list, or you can give a vector or a matrix of integers. If you give more than one matrix of the same size then LCM is done element by element.

  See Wikipedia, Planetmath, or Mathworld for more information.

### Операции с матрицами

AppendElement

      AppendElement (v,elt)

  Append an element to a vector and return the vector. No expansion is done. Normally a row vector is built if starting from `null` or a 1-by-1 matrix, but if given a column vector it will properly build a column vector.

ApplyOverMatrix

      ApplyOverMatrix (a,func)

  Применяет функцию к каждому элементу матрицы и возвращает матрицу результатов.

ApplyOverMatrix2

      ApplyOverMatrix2 (a,b,func)

  Применяет функцию к каждому элементу двух матриц (или 1 значению и 1 матрице) и возвращает матрицу результатов.

ColumnsOf

      ColumnsOf (M)

  Возвращает столбцы матрицы в виде горизонтального вектора.

ComplementSubmatrix

      ComplementSubmatrix (m,r,c)

  Remove column(s) and row(s) from a matrix.

CompoundMatrix

      CompoundMatrix (k,A)

  Calculate the kth compound matrix of A.

CountZeroColumns

      CountZeroColumns (M)

  Count the number of zero columns in a matrix. For example, once you column-reduce a matrix, you can use this to find the nullity. See `cref` and `Nullity`.

DeleteColumn

      DeleteColumn (M,столбец)

  Удаляет столбец матрицы.

DeleteRow

      DeleteRow (M,строка)

  Удаляет строку матрицы.

DiagonalOf

      DiagonalOf (M)

  Gets the diagonal entries of a matrix as a column vector.

  See Wikipedia for more information.

DotProduct

      DotProduct (u,v)

  Get the dot product of two vectors. The vectors must be of the same size. No conjugates are taken so this is a bilinear form even if working over the complex numbers; This is the bilinear scalar product not the sesquilinear scalar product. See HermitianProduct for the standard sesquilinear inner product.

  See Wikipedia or Planetmath for more information.

ExpandMatrix

      ExpandMatrix (M)

  Expands a matrix just like we do on unquoted matrix input. That is we expand any internal matrices as blocks. This is a way to construct matrices out of smaller ones and this is normally done automatically on input unless the matrix is quoted.

HermitianProduct

      HermitianProduct (u,v)

  Aliases: `InnerProduct`

  Get the Hermitian product of two vectors. The vectors must be of the same size. This is a sesquilinear form using the identity matrix.

  See Wikipedia or Mathworld for more information.

I

      I (n)

  Aliases: `eye`

  Return an identity matrix of a given size, that is `n` by `n`. If `n` is zero, returns `null`.

  See Wikipedia or Planetmath for more information.

IndexComplement

      IndexComplement (vec,msize)

  Return the index complement of a vector of indexes. Everything is one based. For example for vector `[2,3]` and size `5`, we return `[1,4,5]`. If `msize` is 0, we always return `null`.

IsDiagonal

      IsDiagonal (M)

  Является ли матрица диагональной.

  See Wikipedia or Planetmath for more information.

IsIdentity

      IsIdentity (x)

  Check if a matrix is the identity matrix. Automatically returns `false` if the matrix is not square. Also works on numbers, in which case it is equivalent to `x==1`. When `x` is `null` (we could think of that as a 0 by 0 matrix), no error is generated and `false` is returned.

IsLowerTriangular

      IsLowerTriangular (M)

  Является ли матрица нижнетреугольной, то есть все её элементы над диагональю равны нулю.

IsMatrixInteger

      IsMatrixInteger (M)

  Check if a matrix is a matrix of integers (non-complex).

IsMatrixNonnegative

      IsMatrixNonnegative (M)

  Check if a matrix is non-negative, that is if each element is non-negative. Do not confuse positive matrices with positive semi-definite matrices.

  See Wikipedia for more information.

IsMatrixPositive

      IsMatrixPositive (M)

  Check if a matrix is positive, that is if each element is positive (and hence real). In particular, no element is 0. Do not confuse positive matrices with positive definite matrices.

  See Wikipedia for more information.

IsMatrixRational

      IsMatrixRational (M)

  Проверяет, является ли матрица матрицей из рациональных (не комплексных) чисел.

IsMatrixReal

      IsMatrixReal (M)

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

IsMatrixSquare

      IsMatrixSquare (M)

  Проверяет, является ли матрица квадратной, то есть её ширина равна высоте.

IsUpperTriangular

      IsUpperTriangular (M)

  Is a matrix upper triangular? That is, a matrix is upper triangular if all the entries below the diagonal are zero.

IsValueOnly

      IsValueOnly (M)

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

IsVector

      IsVector (v)

  Является ли аргумент горизонтальным или вертикальным вектором. Genius не делает различий между матрицей и вектором: вектор — это просто матрица 1 на `n` или `n` на 1.

IsZero

      IsZero (x)

  Проверяет, состоит ли матрица из одних нулей. Также работает с числами, в этом случае эквивалентна выражению `x==0`. Если переменная `x` равна `null` (можно представить это, как матрицу 0 на 0 элементов), ошибка не генерируется и возвращается `true`, так как условие является бессмысленным.

LowerTriangular

      LowerTriangular (M)

  Возвращает копию матрицы `M`, в которой все элементы под диагональю заменены нулями.

MakeDiagonal

      MakeDiagonal (v,arg...)

  Псевдоним: `diag`

  Создаёт диагональную матрицу из вектора. Значения для диагонали также могут быть переданы в виде аргументов функции. Поэтому `MakeDiagonal([1,2,3])` — то же самое, что и `MakeDiagonal(1,2,3)`.

  See Wikipedia or Planetmath for more information.

MakeVector

      MakeVector (A)

  Alias: `MakeColumnVector`

  Make column vector out of matrix by putting columns above each other. Returns `null` when given `null`. Can be used to ensure a vector is a column vector.

MakeRowVector

      MakeRowVector (A)

  Make row vector out of matrix by putting rows one after another. Returns `null` when given `null`. Can be used to ensure a vector is a row vector.

MatrixProduct

      MatrixProduct (A)

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

MatrixSum

      MatrixSum (A)

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

MatrixSumSquares

      MatrixSumSquares (A)

  Вычисляет сумму квадратов всех элементов матрицы или вектора.

NonzeroColumns

      NonzeroColumns (M)

  Returns a row vector of the indices of nonzero columns in the matrix `M`.

  Version 1.0.18 onwards.

NonzeroElements

      NonzeroElements (v)

  Returns a row vector of the indices of nonzero elements in the vector `v`.

  Version 1.0.18 onwards.

OuterProduct

      OuterProduct (u,v)

  Get the outer product of two vectors. That is, suppose that `u` and `v` are vertical vectors, then the outer product is `v * u.'`.

ReverseVector

      ReverseVector (v)

  Reverse elements in a vector. Return `null` if given `null`

RowSum

      RowSum (m)

  Вычисляет суммы элементов в каждой строке матрицы и возвращает вертикальный вектор с результатом.

RowSumSquares

      RowSumSquares (m)

  Вычисляет суммы квадратов элементов в каждой строке матрицы и возвращает вертикальный вектор с результатами.

RowsOf

      RowsOf (M)

  Gets the rows of a matrix as a vertical vector. Each element of the vector is a horizontal vector that is the corresponding row of `M`. This function is useful if you wish to loop over the rows of a matrix. For example, as `for r in RowsOf(M) do something(r)`.

SetMatrixSize

      SetMatrixSize (M,строки,столбцы)

  Make new matrix of given size from old one. That is, a new matrix will be returned to which the old one is copied. Entries that don't fit are clipped and extra space is filled with zeros. If `rows` or `columns` are zero then `null` is returned.

ShuffleVector

      ShuffleVector (v)

  Shuffle elements in a vector. Return `null` if given `null`.

  Version 1.0.13 onwards.

SortVector

      SortVector (v)

  Sort vector elements in an increasing order.

StripZeroColumns

      StripZeroColumns (M)

  Удаляет все состоящие только из нулей столбцы матрицы `M`.

StripZeroRows

      StripZeroRows (M)

  Удаляет все состоящие только из нулей строки матрицы `M`.

Submatrix

      Submatrix (m,r,c)

  Return column(s) and row(s) from a matrix. This is just equivalent to `m@(r,c)`. `r` and `c` should be vectors of rows and columns (or single numbers if only one row or column is needed).

SwapRows

      SwapRows (m,строка1,строка2)

  Меняет местами две строки матрицы.

UpperTriangular

      UpperTriangular (M)

  Возвращает копию матрицы `M`, в которой все элементы под диагональю заменены нулями.

columns

      columns (M)

  Возвращает число столбцов в матрице.

elements

      elements (M)

  Возвращает общее число элементов в матрице. Это число столбцов, умноженное на число строк.

ones

      ones (строки,столбцы...)

  Создаёт матрицу, состоящую только из единиц (или строчный вектор, если задан только один аргумент). Возвращает `null`, если задано число строк или столбцов, равное нулю.

rows

      rows (M)

  Возвращает число строк в матрице.

zeros

      zeros (строки,столбцы...)

  Создаёт матрицу, состоящую только из единиц (или строчный вектор, если задан только один аргумент). Возвращает `null`, если задано число строк или столбцов, равное нулю.

### Линейная алгебра

AuxiliaryUnitMatrix

      AuxiliaryUnitMatrix (n)

  Get the auxiliary unit matrix of size `n`. This is a square matrix with that is all zero except the superdiagonal being all ones. It is the Jordan block matrix of one zero eigenvalue.

  See Planetmath or Mathworld for more information on Jordan Canonical Form.

BilinearForm

      BilinearForm (v,A,w)

  Evaluate (v,w) with respect to the bilinear form given by the matrix A.

BilinearFormFunction

      BilinearFormFunction (A)

  Return a function that evaluates two vectors with respect to the bilinear form given by A.

CharacteristicPolynomial

      CharacteristicPolynomial (M)

  Aliases: `CharPoly`

  Get the characteristic polynomial as a vector. That is, return the coefficients of the polynomial starting with the constant term. This is the polynomial defined by `det(M-xI)`. The roots of this polynomial are the eigenvalues of `M`. See also CharacteristicPolynomialFunction.

  See Wikipedia or Planetmath for more information.

CharacteristicPolynomialFunction

      CharacteristicPolynomialFunction (M)

  Get the characteristic polynomial as a function. This is the polynomial defined by `det(M-xI)`. The roots of this polynomial are the eigenvalues of `M`. See also CharacteristicPolynomial.

  See Wikipedia or Planetmath for more information.

ColumnSpace

      ColumnSpace (M)

  Get a basis matrix for the columnspace of a matrix. That is, return a matrix whose columns are the basis for the column space of `M`. That is the space spanned by the columns of `M`.

  See Wikipedia for more information.

CommutationMatrix

      CommutationMatrix (m, n)

  Return the commutation matrix `K(m,n)`, which is the unique `m*n` by `m*n` matrix such that `K(m,n) * MakeVector(A) = MakeVector(A.')` for all `m` by `n` matrices `A`.

CompanionMatrix

      CompanionMatrix (p)

  Companion matrix of a polynomial (as vector).

ConjugateTranspose

      ConjugateTranspose (M)

  Conjugate transpose of a matrix (adjoint). This is the same as the `'` operator.

  See Wikipedia or Planetmath for more information.

Convolution

      Convolution (a,b)

  Aliases: `convol`

  Calculate convolution of two horizontal vectors.

ConvolutionVector

      ConvolutionVector (a,b)

  Calculate convolution of two horizontal vectors. Return result as a vector and not added together.

CrossProduct

      CrossProduct (v,w)

  CrossProduct of two vectors in R3 as a column vector.

  See Wikipedia for more information.

DeterminantalDivisorsInteger

      DeterminantalDivisorsInteger (M)

  Get the determinantal divisors of an integer matrix.

DirectSum

      DirectSum (M,N...)

  Direct sum of matrices.

  See Wikipedia for more information.

DirectSumMatrixVector

      DirectSumMatrixVector (v)

  Direct sum of a vector of matrices.

  See Wikipedia for more information.

Eigenvalues

      Eigenvalues (M)

  Aliases: `eig`

  Get the eigenvalues of a square matrix. Currently only works for matrices of size up to 4 by 4, or for triangular matrices (for which the eigenvalues are on the diagonal).

  See Wikipedia, Planetmath, or Mathworld for more information.

Eigenvectors

      Eigenvectors (M)

      Eigenvectors (M, &eigenvalues)

      Eigenvectors (M, &eigenvalues, &multiplicities)

  Get the eigenvectors of a square matrix. Optionally get also the eigenvalues and their algebraic multiplicities. Currently only works for matrices of size up to 2 by 2.

  See Wikipedia, Planetmath, or Mathworld for more information.

GramSchmidt

      GramSchmidt (v,B...)

  Apply the Gram-Schmidt process (to the columns) with respect to inner product given by `B`. If `B` is not given then the standard Hermitian product is used. `B` can either be a sesquilinear function of two arguments or it can be a matrix giving a sesquilinear form. The vectors will be made orthonormal with respect to `B`.

  See Wikipedia or Planetmath for more information.

HankelMatrix

      HankelMatrix (c,r)

  Hankel matrix, a matrix whose skew-diagonals are constant. `c` is the first row and `r` is the last column. It is assumed that both arguments are vectors and the last element of `c` is the same as the first element of `r`.

  See Wikipedia for more information.

HilbertMatrix

      HilbertMatrix (n)

  Hilbert matrix of order `n`.

  See Wikipedia or Planetmath for more information.

Image

      Image (T)

  Get the image (columnspace) of a linear transform.

  See Wikipedia for more information.

InfNorm

      InfNorm (v)

  Get the Inf Norm of a vector, sometimes called the sup norm or the max norm.

InvariantFactorsInteger

      InvariantFactorsInteger (M)

  Get the invariant factors of a square integer matrix.

InverseHilbertMatrix

      InverseHilbertMatrix (n)

  Inverse Hilbert matrix of order `n`.

  See Wikipedia or Planetmath for more information.

IsHermitian

      IsHermitian (M)

  Is a matrix Hermitian. That is, is it equal to its conjugate transpose.

  See Wikipedia or Planetmath for more information.

IsInSubspace

      IsInSubspace (v,W)

  Test if a vector is in a subspace.

IsInvertible

      IsInvertible (n)

  Is a matrix (or number) invertible (Integer matrix is invertible if and only if it is invertible over the integers).

IsInvertibleField

      IsInvertibleField (n)

  Is a matrix (or number) invertible over a field.

IsNormal

      IsNormal (M)

  Is `M` a normal matrix. That is, does `M*M' == M'*M`.

  See Planetmath or Mathworld for more information.

IsPositiveDefinite

      IsPositiveDefinite (M)

  Is `M` a Hermitian positive definite matrix. That is if `HermitianProduct(M*v,v)` is always strictly positive for any vector `v`. `M` must be square and Hermitian to be positive definite. The check that is performed is that every principal submatrix has a non-negative determinant. (See HermitianProduct)

  Note that some authors (for example Mathworld) do not require that `M` be Hermitian, and then the condition is on the real part of the inner product, but we do not take this view. If you wish to perform this check, just check the Hermitian part of the matrix `M` as follows: `IsPositiveDefinite(M+M')`.

  See Wikipedia, Planetmath, or Mathworld for more information.

IsPositiveSemidefinite

      IsPositiveSemidefinite (M)

  Is `M` a Hermitian positive semidefinite matrix. That is if `HermitianProduct(M*v,v)` is always non-negative for any vector `v`. `M` must be square and Hermitian to be positive semidefinite. The check that is performed is that every principal submatrix has a non-negative determinant. (See HermitianProduct)

  Note that some authors do not require that `M` be Hermitian, and then the condition is on the real part of the inner product, but we do not take this view. If you wish to perform this check, just check the Hermitian part of the matrix `M` as follows: `IsPositiveSemidefinite(M+M')`.

  See Planetmath or Mathworld for more information.

IsSkewHermitian

      IsSkewHermitian (M)

  Is a matrix skew-Hermitian. That is, is the conjugate transpose equal to negative of the matrix.

  See Planetmath for more information.

IsUnitary

      IsUnitary (M)

  Is a matrix unitary? That is, does `M'*M` and `M*M'` equal the identity.

  See Planetmath or Mathworld for more information.

JordanBlock

      JordanBlock (n,lambda)

  Aliases: `J`

  Get the Jordan block corresponding to the eigenvalue `lambda` with multiplicity `n`.

  See Planetmath or Mathworld for more information.

Kernel

      Kernel (T)

  Get the kernel (nullspace) of a linear transform.

  (See NullSpace)

KroneckerProduct

      KroneckerProduct (M, N)

  Aliases: `TensorProduct`

  Compute the Kronecker product (tensor product in standard basis) of two matrices.

  See Wikipedia, Planetmath or Mathworld for more information.

  Version 1.0.18 onwards.

LUDecomposition

      LUDecomposition (A, L, U)

  Get the LU decomposition of `A`, that is find a lower triangular matrix and upper triangular matrix whose product is `A`. Store the result in the `L` and `U`, which should be references. It returns `true` if successful. For example suppose that A is a square matrix, then after running:

      genius> LUDecomposition(A,&L,&U)

  You will have the lower matrix stored in a variable called `L` and the upper matrix in a variable called `U`.

  This is the LU decomposition of a matrix aka Crout and/or Cholesky reduction. (ISBN 0-201-11577-8 pp.99-103) The upper triangular matrix features a diagonal of values 1 (one). This is not Doolittle's Method, which features the 1's diagonal on the lower matrix.

  Not all matrices have LU decompositions, for example `[0,1;1,0]` does not and this function returns `false` in this case and sets `L` and `U` to `null`.

  See Wikipedia, Planetmath or Mathworld for more information.

Minor

      Minor (M,i,j)

  Get the `i`-`j` minor of a matrix.

  See Planetmath for more information.

NonPivotColumns

      NonPivotColumns (M)

  Return the columns that are not the pivot columns of a matrix.

Norm

      Norm (v,p...)

  Aliases: `norm`

  Get the p Norm (or 2 Norm if no p is supplied) of a vector.

NullSpace

      NullSpace (T)

  Get the nullspace of a matrix. That is the kernel of the linear mapping that the matrix represents. This is returned as a matrix whose column space is the nullspace of `T`.

  See Planetmath for more information.

Nullity

      Nullity (M)

  Aliases: `nullity`

  Get the nullity of a matrix. That is, return the dimension of the nullspace; the dimension of the kernel of `M`.

  See Planetmath for more information.

OrthogonalComplement

      OrthogonalComplement (M)

  Get the orthogonal complement of the columnspace.

PivotColumns

      PivotColumns (M)

  Return pivot columns of a matrix, that is columns that have a leading 1 in row reduced form. Also returns the row where they occur.

Projection

      Projection (v,W,B...)

  Projection of vector `v` onto subspace `W` with respect to inner product given by `B`. If `B` is not given then the standard Hermitian product is used. `B` can either be a sesquilinear function of two arguments or it can be a matrix giving a sesquilinear form.

QRDecomposition

      QRDecomposition (A, Q)

  Get the QR decomposition of a square matrix `A`, returns the upper triangular matrix `R` and sets `Q` to the orthogonal (unitary) matrix. `Q` should be a reference or `null` if you don't want any return. For example:

      genius> R = QRDecomposition(A,&Q)

  You will have the upper triangular matrix stored in a variable called `R` and the orthogonal (unitary) matrix stored in `Q`.

  See Wikipedia or Planetmath or Mathworld for more information.

RayleighQuotient

      RayleighQuotient (A,x)

  Return the Rayleigh quotient (also called the Rayleigh-Ritz quotient or ratio) of a matrix and a vector.

  See Planetmath for more information.

RayleighQuotientIteration

      RayleighQuotientIteration (A,x,epsilon,maxiter,vecref)

  Find eigenvalues of `A` using the Rayleigh quotient iteration method. `x` is a guess at a eigenvector and could be random. It should have nonzero imaginary part if it will have any chance at finding complex eigenvalues. The code will run at most `maxiter` iterations and return `null` if we cannot get within an error of `epsilon`. `vecref` should either be `null` or a reference to a variable where the eigenvector should be stored.

  See Planetmath for more information on Rayleigh quotient.

Rank

      Rank (M)

  Синонимы: `rank`

  Возвращает ранг матрицы.

  See Planetmath for more information.

RosserMatrix

      RosserMatrix ()

  Returns the Rosser matrix, which is a classic symmetric eigenvalue test problem.

Rotation2D

      Rotation2D (angle)

  Aliases: `RotationMatrix`

  Return the matrix corresponding to rotation around origin in R2.

Rotation3DX

      Rotation3DX (angle)

  Return the matrix corresponding to rotation around origin in R3 about the x-axis.

Rotation3DY

      Rotation3DY (angle)

  Return the matrix corresponding to rotation around origin in R3 about the y-axis.

Rotation3DZ

      Rotation3DZ (angle)

  Return the matrix corresponding to rotation around origin in R3 about the z-axis.

RowSpace

      RowSpace (M)

  Get a basis matrix for the rowspace of a matrix.

SesquilinearForm

      SesquilinearForm (v,A,w)

  Evaluate (v,w) with respect to the sesquilinear form given by the matrix A.

SesquilinearFormFunction

      SesquilinearFormFunction (A)

  Return a function that evaluates two vectors with respect to the sesquilinear form given by A.

SmithNormalFormField

      SmithNormalFormField (A)

  Returns the Smith normal form of a matrix over fields (will end up with 1's on the diagonal).

  See Wikipedia for more information.

SmithNormalFormInteger

      SmithNormalFormInteger (M)

  Return the Smith normal form for square integer matrices over integers.

  See Wikipedia for more information.

SolveLinearSystem

      SolveLinearSystem (M,V,args...)

  Solve linear system Mx=V, return solution V if there is a unique solution, `null` otherwise. Extra two reference parameters can optionally be used to get the reduced M and V.

ToeplitzMatrix

      ToeplitzMatrix (c, r...)

  Return the Toeplitz matrix constructed given the first column c and (optionally) the first row r. If only the column c is given then it is conjugated and the nonconjugated version is used for the first row to give a Hermitian matrix (if the first element is real).

  See Wikipedia or Planetmath for more information.

Trace

      Trace (M)

  Aliases: `trace`

  Calculate the trace of a matrix. That is the sum of the diagonal elements.

  See Wikipedia or Planetmath for more information.

Transpose

      Transpose (M)

  Транспозиция матрицы. То же самое, что оператор `.'`.

  See Wikipedia or Planetmath for more information.

VandermondeMatrix

      VandermondeMatrix (v)

  Aliases: `vander`

  Return the Vandermonde matrix.

  See Wikipedia for more information.

VectorAngle

      VectorAngle (v,w,B...)

  The angle of two vectors with respect to inner product given by `B`. If `B` is not given then the standard Hermitian product is used. `B` can either be a sesquilinear function of two arguments or it can be a matrix giving a sesquilinear form.

VectorSpaceDirectSum

      VectorSpaceDirectSum (M,N)

  The direct sum of the vector spaces M and N.

VectorSubspaceIntersection

      VectorSubspaceIntersection (M,N)

  Intersection of the subspaces given by M and N.

VectorSubspaceSum

      VectorSubspaceSum (M,N)

  The sum of the vector spaces M and N, that is {w | w=m+n, m in M, n in N}.

adj

      adj (m)

  Aliases: `Adjugate`

  Get the classical adjoint (adjugate) of a matrix.

cref

      cref (M)

  Aliases: `CREF` `ColumnReducedEchelonForm`

  Compute the Column Reduced Echelon Form.

det

      det (M)

  Aliases: `Determinant`

  Get the determinant of a matrix.

  See Wikipedia or Planetmath for more information.

ref

      ref (M)

  Aliases: `REF` `RowEchelonForm`

  Get the row echelon form of a matrix. That is, apply gaussian elimination but not backaddition to `M`. The pivot rows are divided to make all pivots 1.

  See Wikipedia or Planetmath for more information.

rref

      rref (M)

  Aliases: `RREF` `ReducedRowEchelonForm`

  Get the reduced row echelon form of a matrix. That is, apply gaussian elimination together with backaddition to `M`.

  See Wikipedia or Planetmath for more information.

### Комбинаторика

Catalan

      Catalan (n)

  Возвращает `n`-ое число Каталана.

  See Planetmath for more information.

Combinations

      Combinations (k,n)

  Get all combinations of k numbers from 1 to n as a vector of vectors. (See also NextCombination)

  See Wikipedia for more information.

DoubleFactorial

      DoubleFactorial (n)

  Двойной факториал: `n(n-2)(n-4)...`

  See Planetmath for more information.

Factorial

      Factorial (n)

  Факториал: `n(n-1)(n-2)...`

  See Planetmath for more information.

FallingFactorial

      FallingFactorial (n,k)

  Убывающий факториал: `(n)_k = n(n-1)...(n-(k-1))`

  See Planetmath for more information.

Fibonacci

      Fibonacci (x)

  Синонимы: `fib`

  Вычисляет `n`-ое число Фибоначчи. Это число, вычисляемое рекурсивно по формулам `Fibonacci(n) = Fibonacci(n-1) + Fibonacci(n-2)` и `Fibonacci(1) = Fibonacci(2) = 1`.

  See Wikipedia or Planetmath or Mathworld for more information.

FrobeniusNumber

      FrobeniusNumber (v,arg...)

  Calculate the Frobenius number. That is calculate largest number that cannot be given as a non-negative integer linear combination of a given vector of non-negative integers. The vector can be given as separate numbers or a single vector. All the numbers given should have GCD of 1.

  See Wikipedia or Mathworld for more information.

GaloisMatrix

      GaloisMatrix (combining_rule)

  Galois matrix given a linear combining rule (a_1*x_1+...+a_n*x_n=x_(n+1)).

GreedyAlgorithm

      GreedyAlgorithm (n,v)

  Find the vector `c` of non-negative integers such that taking the dot product with `v` is equal to n. If not possible returns `null`. `v` should be given sorted in increasing order and should consist of non-negative integers.

  See Wikipedia or Mathworld for more information.

HarmonicNumber

      HarmonicNumber (n,r)

  Aliases: `HarmonicH`

  Harmonic Number, the `n`th harmonic number of order `r`. That is, it is the sum of `1/k^r` for `k` from 1 to n. Equivalent to `sum k = 1 to n do 1/k^r`.

  See Wikipedia for more information.

Hofstadter

      Hofstadter (n)

  Hofstadter's function q(n) defined by q(1)=1, q(2)=1, q(n)=q(n-q(n-1))+q(n-q(n-2)).

  See Wikipedia for more information. The sequence is A005185 in OEIS.

LinearRecursiveSequence

      LinearRecursiveSequence (seed_values,combining_rule,n)

  Compute linear recursive sequence using Galois stepping.

Multinomial

      Multinomial (v,arg...)

  Calculate multinomial coefficients. Takes a vector of `k` non-negative integers and computes the multinomial coefficient. This corresponds to the coefficient in the homogeneous polynomial in `k` variables with the corresponding powers.

  The formula for `Multinomial(a,b,c)` can be written as:

      (a+b+c)! / (a!b!c!)

  In other words, if we would have only two elements, then `Multinomial(a,b)` is the same thing as `Binomial(a+b,a)` or `Binomial(a+b,b)`.

  See Wikipedia, Planetmath, or Mathworld for more information.

NextCombination

      NextCombination (v,n)

  Get combination that would come after v in call to combinations, first combination should be `[1:k]`. This function is useful if you have many combinations to go through and you don't want to waste memory to store them all.

  For example with Combinations you would normally write a loop like:

      for n in Combinations (4,6) do (
        SomeFunction (n)
      );

  But with NextCombination you would write something like:

      n:=[1:4];
      do (
        SomeFunction (n)
      ) while not IsNull(n:=NextCombination(n,6));

  See also Combinations.

  See Wikipedia for more information.

Pascal

      Pascal (i)

  Get the Pascal's triangle as a matrix. This will return an `i`+1 by `i`+1 lower diagonal matrix that is the Pascal's triangle after `i` iterations.

  See Planetmath for more information.

Permutations

      Permutations (k,n)

  Get all permutations of `k` numbers from 1 to `n` as a vector of vectors.

  See Mathworld or Wikipedia for more information.

RisingFactorial

      RisingFactorial (n,k)

  Aliases: `Pochhammer`

  (Pochhammer) Rising factorial: (n)_k = n(n+1)...(n+(k-1)).

  See Planetmath for more information.

StirlingNumberFirst

      StirlingNumberFirst (n,m)

  Aliases: `StirlingS1`

  Stirling number of the first kind.

  See Planetmath or Mathworld for more information.

StirlingNumberSecond

      StirlingNumberSecond (n,m)

  Aliases: `StirlingS2`

  Stirling number of the second kind.

  See Planetmath or Mathworld for more information.

Subfactorial

      Subfactorial (n)

  Subfactorial: n! times sum_{k=0}^n (-1)^k/k!.

Triangular

      Triangular (nth)

  Calculate the `n`th triangular number.

  See Planetmath for more information.

nCr

      nCr (n,r)

  Aliases: `Binomial`

  Calculate combinations, that is, the binomial coefficient. `n` can be any real number.

  See Planetmath for more information.

nPr

      nPr (n,r)

  Calculate the number of permutations of size `r` of numbers from 1 to `n`.

  See Mathworld or Wikipedia for more information.

### Calculus

CompositeSimpsonsRule

      CompositeSimpsonsRule (f,a,b,n)

  Integration of f by Composite Simpson's Rule on the interval [a,b] with n subintervals with error of max(f'''')*h^4*(b-a)/180, note that n should be even.

  See Planetmath for more information.

CompositeSimpsonsRuleTolerance

      CompositeSimpsonsRuleTolerance (f,a,b,FourthDerivativeBound,Tolerance)

  Integration of f by Composite Simpson's Rule on the interval [a,b] with the number of steps calculated by the fourth derivative bound and the desired tolerance.

  See Planetmath for more information.

Derivative

      Derivative (f,x0)

  Attempt to calculate derivative by trying first symbolically and then numerically.

  See Wikipedia for more information.

EvenPeriodicExtension

      EvenPeriodicExtension (f,L)

  Return a function that is the even periodic extension of `f` with half period `L`. That is a function defined on the interval `[0,L]` extended to be even on `[-L,L]` and then extended to be periodic with period `2*L`.

  See also OddPeriodicExtension and PeriodicExtension.

  Version 1.0.7 onwards.

FourierSeriesFunction

      FourierSeriesFunction (a,b,L)

  Return a function that is a Fourier series with the coefficients given by the vectors `a` (sines) and `b` (cosines). Note that `a@(1)` is the constant coefficient! That is, `a@(n)` refers to the term `cos(x*(n-1)*pi/L)`, while `b@(n)` refers to the term `sin(x*n*pi/L)`. Either `a` or `b` can be `null`.

  See Wikipedia or Mathworld for more information.

InfiniteProduct

      InfiniteProduct (func,start,inc)

  Try to calculate an infinite product for a single parameter function.

InfiniteProduct2

      InfiniteProduct2 (func,arg,start,inc)

  Try to calculate an infinite product for a double parameter function with func(arg,n).

InfiniteSum

      InfiniteSum (func,start,inc)

  Try to calculate an infinite sum for a single parameter function.

InfiniteSum2

      InfiniteSum2 (func,arg,start,inc)

  Try to calculate an infinite sum for a double parameter function with func(arg,n).

IsContinuous

      IsContinuous (f,x0)

  Try and see if a real-valued function is continuous at x0 by calculating the limit there.

IsDifferentiable

      IsDifferentiable (f,x0)

  Test for differentiability by approximating the left and right limits and comparing.

LeftLimit

      LeftLimit (f,x0)

  Calculate the left limit of a real-valued function at x0.

Limit

      Limit (f,x0)

  Calculate the limit of a real-valued function at x0. Tries to calculate both left and right limits.

MidpointRule

      MidpointRule (f,a,b,n)

  Integration by midpoint rule.

NumericalDerivative

      NumericalDerivative (f,x0)

  Aliases: `NDerivative`

  Attempt to calculate numerical derivative.

  See Wikipedia for more information.

NumericalFourierSeriesCoefficients

      NumericalFourierSeriesCoefficients (f,L,N)

  Return a vector of vectors `[a,b]` where `a` are the cosine coefficients and `b` are the sine coefficients of the Fourier series of `f` with half-period `L` (that is defined on `[-L,L]` and extended periodically) with coefficients up to `N`th harmonic computed numerically. The coefficients are computed by numerical integration using `NumericalIntegral`.

  See Wikipedia or Mathworld for more information.

  Version 1.0.7 onwards.

NumericalFourierSeriesFunction

      NumericalFourierSeriesFunction (f,L,N)

  Return a function that is the Fourier series of `f` with half-period `L` (that is defined on `[-L,L]` and extended periodically) with coefficients up to `N`th harmonic computed numerically. This is the trigonometric real series composed of sines and cosines. The coefficients are computed by numerical integration using `NumericalIntegral`.

  See Wikipedia or Mathworld for more information.

  Version 1.0.7 onwards.

NumericalFourierCosineSeriesCoefficients

      NumericalFourierCosineSeriesCoefficients (f,L,N)

  Return a vector of coefficients of the cosine Fourier series of `f` with half-period `L`. That is, we take `f` defined on `[0,L]` take the even periodic extension and compute the Fourier series, which only has cosine terms. The series is computed up to the `N`th harmonic. The coefficients are computed by numerical integration using `NumericalIntegral`. Note that `a@(1)` is the constant coefficient! That is, `a@(n)` refers to the term `cos(x*(n-1)*pi/L)`.

  See Wikipedia or Mathworld for more information.

  Version 1.0.7 onwards.

NumericalFourierCosineSeriesFunction

      NumericalFourierCosineSeriesFunction (f,L,N)

  Return a function that is the cosine Fourier series of `f` with half-period `L`. That is, we take `f` defined on `[0,L]` take the even periodic extension and compute the Fourier series, which only has cosine terms. The series is computed up to the `N`th harmonic. The coefficients are computed by numerical integration using `NumericalIntegral`.

  See Wikipedia or Mathworld for more information.

  Version 1.0.7 onwards.

NumericalFourierSineSeriesCoefficients

      NumericalFourierSineSeriesCoefficients (f,L,N)

  Return a vector of coefficients of the sine Fourier series of `f` with half-period `L`. That is, we take `f` defined on `[0,L]` take the odd periodic extension and compute the Fourier series, which only has sine terms. The series is computed up to the `N`th harmonic. The coefficients are computed by numerical integration using `NumericalIntegral`.

  See Wikipedia or Mathworld for more information.

  Version 1.0.7 onwards.

NumericalFourierSineSeriesFunction

      NumericalFourierSineSeriesFunction (f,L,N)

  Return a function that is the sine Fourier series of `f` with half-period `L`. That is, we take `f` defined on `[0,L]` take the odd periodic extension and compute the Fourier series, which only has sine terms. The series is computed up to the `N`th harmonic. The coefficients are computed by numerical integration using `NumericalIntegral`.

  See Wikipedia or Mathworld for more information.

  Version 1.0.7 onwards.

NumericalIntegral

      NumericalIntegral (f,a,b)

  Integration by rule set in NumericalIntegralFunction of f from a to b using NumericalIntegralSteps steps.

NumericalLeftDerivative

      NumericalLeftDerivative (f,x0)

  Attempt to calculate numerical left derivative.

NumericalLimitAtInfinity

      NumericalLimitAtInfinity (_f,step_fun,tolerance,successive_for_success,N)

  Attempt to calculate the limit of f(step_fun(i)) as i goes from 1 to N.

NumericalRightDerivative

      NumericalRightDerivative (f,x0)

  Attempt to calculate numerical right derivative.

OddPeriodicExtension

      OddPeriodicExtension (f,L)

  Return a function that is the odd periodic extension of `f` with half period `L`. That is a function defined on the interval `[0,L]` extended to be odd on `[-L,L]` and then extended to be periodic with period `2*L`.

  See also EvenPeriodicExtension and PeriodicExtension.

  Version 1.0.7 onwards.

OneSidedFivePointFormula

      OneSidedFivePointFormula (f,x0,h)

  Compute one-sided derivative using five point formula.

OneSidedThreePointFormula

      OneSidedThreePointFormula (f,x0,h)

  Compute one-sided derivative using three-point formula.

PeriodicExtension

      PeriodicExtension (f,a,b)

  Return a function that is the periodic extension of `f` defined on the interval `[a,b]` and has period `b-a`.

  See also OddPeriodicExtension and EvenPeriodicExtension.

  Version 1.0.7 onwards.

RightLimit

      RightLimit (f,x0)

  Calculate the right limit of a real-valued function at x0.

TwoSidedFivePointFormula

      TwoSidedFivePointFormula (f,x0,h)

  Compute two-sided derivative using five-point formula.

TwoSidedThreePointFormula

      TwoSidedThreePointFormula (f,x0,h)

  Compute two-sided derivative using three-point formula.

### Functions

Argument

      Argument (z)

  Aliases: `Arg` `arg`

  argument (angle) of complex number.

BesselJ0

      BesselJ0 (x)

  Bessel function of the first kind of order 0. Only implemented for real numbers.

  See Wikipedia for more information.

  Version 1.0.16 onwards.

BesselJ1

      BesselJ1 (x)

  Bessel function of the first kind of order 1. Only implemented for real numbers.

  See Wikipedia for more information.

  Version 1.0.16 onwards.

BesselJn

      BesselJn (n,x)

  Bessel function of the first kind of order `n`. Only implemented for real numbers.

  See Wikipedia for more information.

  Version 1.0.16 onwards.

BesselY0

      BesselY0 (x)

  Bessel function of the second kind of order 0. Only implemented for real numbers.

  See Wikipedia for more information.

  Version 1.0.16 onwards.

BesselY1

      BesselY1 (x)

  Bessel function of the second kind of order 1. Only implemented for real numbers.

  See Wikipedia for more information.

  Version 1.0.16 onwards.

BesselYn

      BesselYn (n,x)

  Bessel function of the second kind of order `n`. Only implemented for real numbers.

  See Wikipedia for more information.

  Version 1.0.16 onwards.

DirichletKernel

      DirichletKernel (n,t)

  Dirichlet kernel of order `n`.

DiscreteDelta

      DiscreteDelta (v)

  Returns 1 if and only if all elements are zero.

ErrorFunction

      ErrorFunction (x)

  Aliases: `erf`

  The error function, 2/sqrt(pi) * int_0^x e^(-t^2) dt.

  See Wikipedia or Planetmath for more information.

FejerKernel

      FejerKernel (n,t)

  Fejer kernel of order `n` evaluated at `t`

  See Planetmath for more information.

GammaFunction

      GammaFunction (x)

  Aliases: `Gamma`

  The Gamma function. Currently only implemented for real values.

  See Planetmath or Wikipedia for more information.

KroneckerDelta

      KroneckerDelta (v)

  Returns 1 if and only if all elements are equal.

LambertW

      LambertW (x)

  The principal branch of Lambert W function computed for only real values greater than or equal to `-1/e`. That is, `LambertW` is the inverse of the expression `x*e^x`. Even for real `x` this expression is not one to one and therefore has two branches over `[-1/e,0)`. See `LambertWm1` for the other real branch.

  See Wikipedia for more information.

  Version 1.0.18 onwards.

LambertWm1

      LambertWm1 (x)

  The minus-one branch of Lambert W function computed for only real values greater than or equal to `-1/e` and less than 0. That is, `LambertWm1` is the second branch of the inverse of `x*e^x`. See `LambertW` for the principal branch.

  See Wikipedia for more information.

MinimizeFunction

      MinimizeFunction (func,x,incr)

  Find the first value where f(x)=0.

MoebiusDiskMapping

      MoebiusDiskMapping (a,z)

  Moebius mapping of the disk to itself mapping a to 0.

  See Wikipedia or Planetmath for more information.

MoebiusMapping

      MoebiusMapping (z,z2,z3,z4)

  Moebius mapping using the cross ratio taking z2,z3,z4 to 1,0, and infinity respectively.

  See Wikipedia or Planetmath for more information.

MoebiusMappingInftyToInfty

      MoebiusMappingInftyToInfty (z,z2,z3)

  Moebius mapping using the cross ratio taking infinity to infinity and z2,z3 to 1 and 0 respectively.

  See Wikipedia or Planetmath for more information.

MoebiusMappingInftyToOne

      MoebiusMappingInftyToOne (z,z3,z4)

  Moebius mapping using the cross ratio taking infinity to 1 and z3,z4 to 0 and infinity respectively.

  See Wikipedia or Planetmath for more information.

MoebiusMappingInftyToZero

      MoebiusMappingInftyToZero (z,z2,z4)

  Moebius mapping using the cross ratio taking infinity to 0 and z2,z4 to 1 and infinity respectively.

  See Wikipedia or Planetmath for more information.

PoissonKernel

      PoissonKernel (r,sigma)

  Poisson kernel on D(0,1) (not normalized to 1, that is integral of this is 2pi).

PoissonKernelRadius

      PoissonKernelRadius (r,sigma)

  Poisson kernel on D(0,R) (not normalized to 1).

RiemannZeta

      RiemannZeta (x)

  Aliases: `zeta`

  The Riemann zeta function. Currently only implemented for real values.

  See Planetmath or Wikipedia for more information.

UnitStep

      UnitStep (x)

  The unit step function is 0 for x<0, 1 otherwise. This is the integral of the Dirac Delta function. Also called the Heaviside function.

  See Wikipedia for more information.

cis

      cis (x)

  Функция `cis`, то же самое, что `cos(x)+1i*sin(x)`

deg2rad

      deg2rad (x)

  Преобразует градусы в радианы.

rad2deg

      rad2deg (x)

  Преобразует радианы в градусы.

sinc

      sinc (x)

  Calculates the unnormalized sinc function, that is `sin(x)/x`. If you want the normalized function call `sinc(pi*x)`.

  See Wikipedia for more information.

  Version 1.0.16 onwards.

### Решение уравнений

CubicFormula

      CubicFormula (p)

  Compute roots of a cubic (degree 3) polynomial using the cubic formula. The polynomial should be given as a vector of coefficients. That is `4*x^3 + 2*x + 1` corresponds to the vector `[1,2,0,4]`. Returns a column vector of the three solutions. The first solution is always the real one as a cubic always has one real solution.

  See Planetmath, Mathworld, or Wikipedia for more information.

EulersMethod

      EulersMethod (f,x0,y0,x1,n)

  Use classical Euler's method to numerically solve y'=f(x,y) for initial `x0`, `y0` going to `x1` with `n` increments, returns `y` at `x1`. Unless you explicitly want to use Euler's method, you should really think about using RungeKutta for solving ODE.

  Systems can be solved by just having `y` be a (column) vector everywhere. That is, `y0` can be a vector in which case `f` should take a number `x` and a vector of the same size for the second argument and should return a vector of the same size.

  See Mathworld or Wikipedia for more information.

EulersMethodFull

      EulersMethodFull (f,x0,y0,x1,n)

  Use classical Euler's method to numerically solve y'=f(x,y) for initial `x0`, `y0` going to `x1` with `n` increments, returns an `n+1` by 2 matrix with the `x` and `y` values. Unless you explicitly want to use Euler's method, you should really think about using RungeKuttaFull for solving ODE. Suitable for plugging into LinePlotDrawLine or LinePlotDrawPoints.

  Example:

      genius> LinePlotClear();
      genius> line = EulersMethodFull(`(x,y)=y,0,1.0,3.0,50);
      genius> LinePlotDrawLine(line,"window","fit","color","blue","legend","Exponential growth");

  Systems can be solved by just having `y` be a (column) vector everywhere. That is, `y0` can be a vector in which case `f` should take a number `x` and a vector of the same size for the second argument and should return a vector of the same size.

  The output for a system is still a n by 2 matrix with the second entry being a vector. If you wish to plot the line, make sure to use row vectors, and then flatten the matrix with ExpandMatrix, and pick out the right columns. Example:

      genius> LinePlotClear();
      genius> lines = EulersMethodFull(`(x,y)=[y@(2),-y@(1)],0,[1.0,1.0],10.0,500);
      genius> lines = ExpandMatrix(lines);
      genius> firstline = lines@(,[1,2]);
      genius> secondline = lines@(,[1,3]);
      genius> LinePlotWindow = [0,10,-2,2];
      genius> LinePlotDrawLine(firstline,"color","blue","legend","First");
      genius> LinePlotDrawPoints(secondline,"color","red","thickness",3,"legend","Second");

  See Mathworld or Wikipedia for more information.

  Version 1.0.10 onwards.

FindRootBisection

      FindRootBisection (f,a,b,TOL,N)

  Find root of a function using the bisection method. `a` and `b` are the initial guess interval, `f(a)` and `f(b)` should have opposite signs. `TOL` is the desired tolerance and `N` is the limit on the number of iterations to run, 0 means no limit. The function returns a vector `[success,value,iteration]`, where `success` is a boolean indicating success, `value` is the last value computed, and `iteration` is the number of iterations done.

FindRootFalsePosition

      FindRootFalsePosition (f,a,b,TOL,N)

  Find root of a function using the method of false position. `a` and `b` are the initial guess interval, `f(a)` and `f(b)` should have opposite signs. `TOL` is the desired tolerance and `N` is the limit on the number of iterations to run, 0 means no limit. The function returns a vector `[success,value,iteration]`, where `success` is a boolean indicating success, `value` is the last value computed, and `iteration` is the number of iterations done.

FindRootMullersMethod

      FindRootMullersMethod (f,x0,x1,x2,TOL,N)

  Find root of a function using the Muller's method. `TOL` is the desired tolerance and `N` is the limit on the number of iterations to run, 0 means no limit. The function returns a vector `[success,value,iteration]`, where `success` is a boolean indicating success, `value` is the last value computed, and `iteration` is the number of iterations done.

FindRootSecant

      FindRootSecant (f,a,b,TOL,N)

  Find root of a function using the secant method. `a` and `b` are the initial guess interval, `f(a)` and `f(b)` should have opposite signs. `TOL` is the desired tolerance and `N` is the limit on the number of iterations to run, 0 means no limit. The function returns a vector `[success,value,iteration]`, where `success` is a boolean indicating success, `value` is the last value computed, and `iteration` is the number of iterations done.

HalleysMethod

      HalleysMethod (f,df,ddf,guess,epsilon,maxn)

  Find zeros using Halley's method. `f` is the function, `df` is the derivative of `f`, and `ddf` is the second derivative of `f`. `guess` is the initial guess. The function returns after two successive values are within `epsilon` of each other, or after `maxn` tries, in which case the function returns `null` indicating failure.

  See also `NewtonsMethod` and `SymbolicDerivative`.

  Example to find the square root of 10:

      genius> HalleysMethod(`(x)=x^2-10,`(x)=2*x,`(x)=2,3,10^-10,100)

  See Wikipedia for more information.

  Version 1.0.18 onwards.

NewtonsMethod

      NewtonsMethod (f,df,guess,epsilon,maxn)

  Find zeros using Newton's method. `f` is the function and `df` is the derivative of `f`. `guess` is the initial guess. The function returns after two successive values are within `epsilon` of each other, or after `maxn` tries, in which case the function returns `null` indicating failure.

  See also `NewtonsMethodPoly` and `SymbolicDerivative`.

  Example to find the square root of 10:

      genius> NewtonsMethod(`(x)=x^2-10,`(x)=2*x,3,10^-10,100)

  See Wikipedia for more information.

  Version 1.0.18 onwards.

PolynomialRoots

      PolynomialRoots (p)

  Compute roots of a polynomial (degrees 1 through 4) using one of the formulas for such polynomials. The polynomial should be given as a vector of coefficients. That is `4*x^3 + 2*x + 1` corresponds to the vector `[1,2,0,4]`. Returns a column vector of the solutions.

  The function calls QuadraticFormula, CubicFormula, and QuarticFormula.

QuadraticFormula

      QuadraticFormula (p)

  Compute roots of a quadratic (degree 2) polynomial using the quadratic formula. The polynomial should be given as a vector of coefficients. That is `3*x^2 + 2*x + 1` corresponds to the vector `[1,2,3]`. Returns a column vector of the two solutions.

  See Planetmath, or Mathworld, or Wikipedia for more information.

QuarticFormula

      QuarticFormula (p)

  Compute roots of a quartic (degree 4) polynomial using the quartic formula. The polynomial should be given as a vector of coefficients. That is `5*x^4 + 2*x + 1` corresponds to the vector `[1,2,0,0,5]`. Returns a column vector of the four solutions.

  See Planetmath, Mathworld, or Wikipedia for more information.

RungeKutta

      RungeKutta (f,x0,y0,x1,n)

  Use classical non-adaptive fourth order Runge-Kutta method to numerically solve y'=f(x,y) for initial `x0`, `y0` going to `x1` with `n` increments, returns `y` at `x1`.

  Systems can be solved by just having `y` be a (column) vector everywhere. That is, `y0` can be a vector in which case `f` should take a number `x` and a vector of the same size for the second argument and should return a vector of the same size.

  See Mathworld or Wikipedia for more information.

RungeKuttaFull

      RungeKuttaFull (f,x0,y0,x1,n)

  Use classical non-adaptive fourth order Runge-Kutta method to numerically solve y'=f(x,y) for initial `x0`, `y0` going to `x1` with `n` increments, returns an `n+1` by 2 matrix with the `x` and `y` values. Suitable for plugging into LinePlotDrawLine or LinePlotDrawPoints.

  Example:

      genius> LinePlotClear();
      genius> line = RungeKuttaFull(`(x,y)=y,0,1.0,3.0,50);
      genius> LinePlotDrawLine(line,"window","fit","color","blue","legend","Exponential growth");

  Systems can be solved by just having `y` be a (column) vector everywhere. That is, `y0` can be a vector in which case `f` should take a number `x` and a vector of the same size for the second argument and should return a vector of the same size.

  The output for a system is still a n by 2 matrix with the second entry being a vector. If you wish to plot the line, make sure to use row vectors, and then flatten the matrix with ExpandMatrix, and pick out the right columns. Example:

      genius> LinePlotClear();
      genius> lines = RungeKuttaFull(`(x,y)=[y@(2),-y@(1)],0,[1.0,1.0],10.0,100);
      genius> lines = ExpandMatrix(lines);
      genius> firstline = lines@(,[1,2]);
      genius> secondline = lines@(,[1,3]);
      genius> LinePlotWindow = [0,10,-2,2];
      genius> LinePlotDrawLine(firstline,"color","blue","legend","First");
      genius> LinePlotDrawPoints(secondline,"color","red","thickness",3,"legend","Second");

  See Mathworld or Wikipedia for more information.

  Version 1.0.10 onwards.

### Статистика

Average

      Average (m)

  Aliases: `average` `Mean` `mean`

  Calculate average (the arithmetic mean) of an entire matrix.

  See Wikipedia or Mathworld for more information.

GaussDistribution

      GaussDistribution (x,sigma)

  Integral of the GaussFunction from 0 to `x` (area under the normal curve).

  See Wikipedia or Mathworld for more information.

GaussFunction

      GaussFunction (x,sigma)

  The normalized Gauss distribution function (the normal curve).

  See Wikipedia or Mathworld for more information.

Median

      Median (m)

  Aliases: `median`

  Calculate median of an entire matrix.

  See Wikipedia or Mathworld for more information.

PopulationStandardDeviation

      PopulationStandardDeviation (m)

  Aliases: `stdevp`

  Calculate the population standard deviation of a whole matrix.

RowAverage

      RowAverage (m)

  Aliases: `RowMean`

  Calculate average of each row in a matrix. That is, compute the arithmetic mean.

  See Wikipedia or Mathworld for more information.

RowMedian

      RowMedian (m)

  Calculate median of each row in a matrix and return a column vector of the medians.

  See Wikipedia or Mathworld for more information.

RowPopulationStandardDeviation

      RowPopulationStandardDeviation (m)

  Aliases: `rowstdevp`

  Calculate the population standard deviations of rows of a matrix and return a vertical vector.

RowStandardDeviation

      RowStandardDeviation (m)

  Aliases: `rowstdev`

  Calculate the standard deviations of rows of a matrix and return a vertical vector.

StandardDeviation

      StandardDeviation (m)

  Aliases: `stdev`

  Calculate the standard deviation of a whole matrix.

### Многочлены

AddPoly

      AddPoly (p1,p2)

  Складывает два многочлена (в виде векторов).

DividePoly

      DividePoly (p,q,&r)

  Divide two polynomials (as vectors) using long division. Returns the quotient of the two polynomials. The optional argument `r` is used to return the remainder. The remainder will have lower degree than `q`.

  See Planetmath for more information.

IsPoly

      IsPoly (p)

  Проверяет, можно ли использовать вектор в качестве многочлена.

MultiplyPoly

      MultiplyPoly (p1,p2)

  Умножает два многочлена (в виде векторов).

NewtonsMethodPoly

      NewtonsMethodPoly (poly,guess,epsilon,maxn)

  Find a root of a polynomial using Newton's method. `poly` is the polynomial as a vector and `guess` is the initial guess. The function returns after two successive values are within `epsilon` of each other, or after `maxn` tries, in which case the function returns `null` indicating failure.

  See also `NewtonsMethod`.

  Example to find the square root of 10:

      genius> NewtonsMethodPoly([-10,0,1],3,10^-10,100)

  See Wikipedia for more information.

Poly2ndDerivative

      Poly2ndDerivative (p)

  Находит вторую производную многочлена (как вектора).

PolyDerivative

      PolyDerivative (p)

  Находит производную многочлена (как вектора).

PolyToFunction

      PolyToFunction (p)

  Make function out of a polynomial (as vector).

PolyToString

      PolyToString (p,var...)

  Make string out of a polynomial (as vector).

SubtractPoly

      SubtractPoly (p1,p2)

  Subtract two polynomials (as vectors).

TrimPoly

      TrimPoly (p)

  Trim zeros from a polynomial (as vector).

### Теория множеств

Intersection

      Intersection (X,Y)

  Возвращает пересечение множеств X и Y (X и Y — векторы, изображающие множества).

IsIn

      IsIn (x,X)

  Возвращает `true`, если элемент x присуствует в множестве X (где X — вектор, изображающий множество).

IsSubset

      IsSubset (X, Y)

  Возвращает `true`, если X является подмножеством Y (X и Y — векторы, изображающие множество).

MakeSet

      MakeSet (X)

  Returns a vector where every element of X appears only once.

SetMinus

      SetMinus (X,Y)

  Returns a set theoretic difference X-Y (X and Y are vectors pretending to be sets).

Union

      Union (X,Y)

  Возвращает объединение множеств X и Y (X и Y — векторы, изображающие множества).

### Commutative Algebra

MacaulayBound

      MacaulayBound (c,d)

  For a Hilbert function that is c for degree d, given the Macaulay bound for the Hilbert function of degree d+1 (The c^<d> operator from Green's proof).

  Version 1.0.15 onwards.

MacaulayLowerOperator

      MacaulayLowerOperator (c,d)

  The c_<d> operator from Green's proof of Macaulay's Theorem.

  Version 1.0.15 onwards.

MacaulayRep

      MacaulayRep (c,d)

  Return the dth Macaulay representation of a positive integer c.

  Version 1.0.15 onwards.

### Прочие

ASCIIToString

      ASCIIToString (vec)

  Convert a vector of ASCII values to a string. See also `StringToASCII`.

  Example:

      genius> ASCIIToString([97,98,99])
      = "abc"

  See Wikipedia for more information.

AlphabetToString

      AlphabetToString (vec,alphabet)

  Convert a vector of 0-based alphabet values (positions in the alphabet string) to a string. A `null` vector results in an empty string. See also `StringToAlphabet`.

  Examples:

      genius> AlphabetToString([1,2,3,0,0],"abcd")
      = "bcdaa"
      genius> AlphabetToString(null,"abcd")
      = ""

StringToASCII

      StringToASCII (str)

  Convert a string to a (row) vector of ASCII values. See also `ASCIIToString`.

  Example:

      genius> StringToASCII("abc")
      = [97, 98, 99]

  See Wikipedia for more information.

StringToAlphabet

      StringToAlphabet (str,alphabet)

  Convert a string to a (row) vector of 0-based alphabet values (positions in the alphabet string), -1's for unknown letters. An empty string results in a `null`. See also `AlphabetToString`.

  Examples:

      genius> StringToAlphabet("cca","abcd")
      = [2, 2, 0]
      genius> StringToAlphabet("ccag","abcd")
      = [2, 2, 0, -1]

### Symbolic Operations

SymbolicDerivative

      SymbolicDerivative (f)

  Attempt to symbolically differentiate the function f, where f is a function of one variable.

  Examples:

      genius> SymbolicDerivative(sin)
      = (`(x)=cos(x))
      genius> SymbolicDerivative(`(x)=7*x^2)
      = (`(x)=(7*(2*x)))

  See Wikipedia for more information.

SymbolicDerivativeTry

      SymbolicDerivativeTry (f)

  Attempt to symbolically differentiate the function f, where f is a function of one variable, returns `null` if unsuccessful but is silent. (See `SymbolicDerivative`)

  See Wikipedia for more information.

SymbolicNthDerivative

      SymbolicNthDerivative (f,n)

  Attempt to symbolically differentiate a function n times. (See `SymbolicDerivative`)

  See Wikipedia for more information.

SymbolicNthDerivativeTry

      SymbolicNthDerivativeTry (f,n)

  Attempt to symbolically differentiate a function n times quietly and return `null` on failure (See `SymbolicNthDerivative`)

  See Wikipedia for more information.

SymbolicTaylorApproximationFunction

      SymbolicTaylorApproximationFunction (f,x0,n)

  Attempt to construct the Taylor approximation function around x0 to the nth degree. (See `SymbolicDerivative`)

### Построение графиков

ExportPlot

      ExportPlot (file,type)

      ExportPlot (file)

  Export the contents of the plotting window to a file. The type is a string that specifies the file type to use, "png", "eps", or "ps". If the type is not specified, then it is taken to be the extension, in which case the extension must be ".png", ".eps", or ".ps".

  Note that files are overwritten without asking.

  On successful export, true is returned. Otherwise error is printed and exception is raised.

  Examples:

      genius> ExportPlot("file.png")
      genius> ExportPlot("/directory/file","eps")

  Version 1.0.16 onwards.

LinePlot

      LinePlot (func1,func2,func3,...)

      LinePlot (func1,func2,func3,x1,x2)

      LinePlot (func1,func2,func3,x1,x2,y1,y2)

      LinePlot (func1,func2,func3,[x1,x2])

      LinePlot (func1,func2,func3,[x1,x2,y1,y2])

  Plot a function (or several functions) with a line. First (up to 10) arguments are functions, then optionally you can specify the limits of the plotting window as `x1`, `x2`, `y1`, `y2`. If limits are not specified, then the currently set limits apply (See `LinePlotWindow`) If the y limits are not specified, then the functions are computed and then the maxima and minima are used.

  The parameter `LinePlotDrawLegends` controls the drawing of the legend.

  Examples:

      genius> LinePlot(sin,cos)
      genius> LinePlot(`(x)=x^2,-1,1,0,1)

LinePlotClear

      LinePlotClear ()

  Show the line plot window and clear out functions and any other lines that were drawn.

LinePlotCParametric

      LinePlotCParametric (func,...)

      LinePlotCParametric (func,t1,t2,tinc)

      LinePlotCParametric (func,t1,t2,tinc,x1,x2,y1,y2)

  Plot a parametric complex valued function with a line. First comes the function that returns `x+iy`, then optionally the `t` limits as `t1,t2,tinc`, then optionally the limits as `x1,x2,y1,y2`.

  If limits are not specified, then the currently set limits apply (See `LinePlotWindow`). If instead the string "fit" is given for the x and y limits, then the limits are the maximum extent of the graph

  The parameter `LinePlotDrawLegends` controls the drawing of the legend.

LinePlotDrawLine

      LinePlotDrawLine (x1,y1,x2,y2,...)

      LinePlotDrawLine (v,...)

  Draw a line from `x1`,`y1` to `x2`,`y2`. `x1`,`y1`, `x2`,`y2` can be replaced by an `n` by 2 matrix for a longer polyline. Alternatively the vector `v` may be a column vector of complex numbers, that is an `n` by 1 matrix and each complex number is then considered a point in the plane.

  Extra parameters can be added to specify line color, thickness, arrows, the plotting window, or legend. You can do this by adding an argument string `"color"`, `"thickness"`, `"window"`, `"arrow"`, or `"legend"`, and after it specify the color, the thickness, the window as 4-vector, type of arrow, or the legend. (Arrow and window are from version 1.0.6 onwards.)

  If the line is to be treated as a filled polygon, filled with the given color, you can specify the argument `"filled"`. Since version 1.0.22 onwards.

  The color should be either a string indicating the common English word for the color that GTK will recognize such as `"red"`, `"blue"`, `"yellow"`, etc... Alternatively the color can be specified in RGB format as `"#rgb"`, `"#rrggbb"`, or `"#rrrrggggbbbb"`, where the r, g, or b are hex digits of the red, green, and blue components of the color. Finally, since version 1.0.18, the color can also be specified as a real vector specifying the red green and blue components where the components are between 0 and 1, e.g. `[1.0,0.5,0.1]`.

  The window should be given as usual as `[x1,x2,y1,y2]`, or alternatively can be given as a string `"fit"` in which case, the x range will be set precisely and the y range will be set with five percent borders around the line.

  Arrow specification should be `"origin"`, `"end"`, `"both"`, or `"none"`.

  Finally, legend should be a string that can be used as the legend in the graph. That is, if legends are being printed.

  Examples:

      genius> LinePlotDrawLine(0,0,1,1,"color","blue","thickness",3)
      genius> LinePlotDrawLine([0,0;1,-1;-1,-1])
      genius> LinePlotDrawLine([0,0;1,1],"arrow","end")
      genius> LinePlotDrawLine(RungeKuttaFull(`(x,y)=y,0,0.001,10,100),"color","blue","legend","The Solution")
      genius> for r=0.0 to 1.0 by 0.1 do LinePlotDrawLine([0,0;1,r],"color",[r,(1-r),0.5],"window",[0,1,0,1])
      genius> LinePlotDrawLine([0,0;10,0;10,10;0,10],"filled","color","green")

  Unlike many other functions that do not care if they take a column or a row vector, if specifying points as a vector of complex values, due to possible ambiguities, it must always be given as a column vector.

  Specifying `v` as a column vector of complex numbers is implemented from version 1.0.22 and onwards.

LinePlotDrawPoints

      LinePlotDrawPoints (x,y,...)

      LinePlotDrawPoints (v,...)

  Draw a point at `x`,`y`. The input can be an `n` by 2 matrix for `n` different points. This function has essentially the same input as LinePlotDrawLine. Alternatively the vector `v` may be a column vector of complex numbers, that is an `n` by 1 matrix and each complex number is then considered a point in the plane.

  Extra parameters can be added to specify color, thickness, the plotting window, or legend. You can do this by adding an argument string `"color"`, `"thickness"`, `"window"`, or `"legend"`, and after it specify the color, the thickness, the window as 4-vector, or the legend.

  The color should be either a string indicating the common English word for the color that GTK will recognize such as `"red"`, `"blue"`, `"yellow"`, etc... Alternatively the color can be specified in RGB format as `"#rgb"`, `"#rrggbb"`, or `"#rrrrggggbbbb"`, where the r, g, or b are hex digits of the red, green, and blue components of the color. Finally the color can also be specified as a real vector specifying the red green and blue components where the components are between 0 and 1.

  The window should be given as usual as `[x1,x2,y1,y2]`, or alternatively can be given as a string `"fit"` in which case, the x range will be set precisely and the y range will be set with five percent borders around the line.

  Finally, legend should be a string that can be used as the legend in the graph. That is, if legends are being printed.

  Examples:

      genius> LinePlotDrawPoints(0,0,"color","blue","thickness",3)
      genius> LinePlotDrawPoints([0,0;1,-1;-1,-1])
      genius> LinePlotDrawPoints(RungeKuttaFull(`(x,y)=y,0,0.001,10,100),"color","blue","legend","The Solution")
      genius> LinePlotDrawPoints([1;1+1i;1i;0],"thickness",5)
      genius> LinePlotDrawPoints(ApplyOverMatrix((0:6)',`(k)=exp(k*2*pi*1i/7)),"thickness",3,"legend","The 7th roots of unity")

  Unlike many other functions that do not care if they take a column or a row vector, if specifying points as a vector of complex values, due to possible ambiguities, it must always be given as a column vector. Therefore, notice in the last example the transpose of the vector `0:6` to make it into a column vector.

  Available from version 1.0.18 onwards. Specifying `v` as a column vector of complex numbers is implemented from version 1.0.22 and onwards.

LinePlotMouseLocation

      LinePlotMouseLocation ()

  Returns a row vector of a point on the line plot corresponding to the current mouse location. If the line plot is not visible, then prints an error and returns `null`. In this case you should run `LinePlot` or `LinePlotClear` to put the graphing window into the line plot mode. See also `LinePlotWaitForClick`.

LinePlotParametric

      LinePlotParametric (xfunc,yfunc,...)

      LinePlotParametric (xfunc,yfunc,t1,t2,tinc)

      LinePlotParametric (xfunc,yfunc,t1,t2,tinc,x1,x2,y1,y2)

      LinePlotParametric (xfunc,yfunc,t1,t2,tinc,[x1,x2,y1,y2])

      LinePlotParametric (xfunc,yfunc,t1,t2,tinc,"fit")

  Plot a parametric function with a line. First come the functions for `x` and `y` then optionally the `t` limits as `t1,t2,tinc`, then optionally the limits as `x1,x2,y1,y2`.

  If x and y limits are not specified, then the currently set limits apply (See `LinePlotWindow`). If instead the string "fit" is given for the x and y limits, then the limits are the maximum extent of the graph

  The parameter `LinePlotDrawLegends` controls the drawing of the legend.

LinePlotWaitForClick

      LinePlotWaitForClick ()

  If in line plot mode, waits for a click on the line plot window and returns the location of the click as a row vector. If the window is closed the function returns immediately with `null`. If the window is not in line plot mode, it is put in it and shown if not shown. See also `LinePlotMouseLocation`.

PlotCanvasFreeze

      PlotCanvasFreeze ()

  Freeze drawing of the canvas plot temporarily. Useful if you need to draw a bunch of elements and want to delay drawing everything to avoid flicker in an animation. After everything has been drawn you should call `PlotCanvasThaw`.

  The canvas is always thawed after end of any execution, so it will never remain frozen. The moment a new command line is shown for example the plot canvas is thawed automatically. Also note that calls to freeze and thaw may be safely nested.

  Version 1.0.18 onwards.

PlotCanvasThaw

      PlotCanvasThaw ()

  Thaw the plot canvas frozen by `PlotCanvasFreeze` and redraw the canvas immediately. The canvas is also always thawed after end of execution of any program.

  Version 1.0.18 onwards.

PlotWindowPresent

      PlotWindowPresent ()

  Show and raise the plot window, creating it if necessary. Normally the window is created when one of the plotting functions is called, but it is not always raised if it happens to be below other windows. So this function is good to call in scripts where the plot window might have been created before, and by now is hidden behind the console or other windows.

  Version 1.0.19 onwards.

SlopefieldClearSolutions

      SlopefieldClearSolutions ()

  Clears the solutions drawn by the `SlopefieldDrawSolution` function.

SlopefieldDrawSolution

      SlopefieldDrawSolution (x, y, dx)

  When a slope field plot is active, draw a solution with the specified initial condition. The standard Runge-Kutta method is used with increment `dx`. Solutions stay on the graph until a different plot is shown or until you call `SlopefieldClearSolutions`. You can also use the graphical interface to draw solutions and specify initial conditions with the mouse.

SlopefieldPlot

      SlopefieldPlot (func)

      SlopefieldPlot (func,x1,x2,y1,y2)

  Plot a slope field. The function `func` should take two real numbers `x` and `y`, or a single complex number. Optionally you can specify the limits of the plotting window as `x1`, `x2`, `y1`, `y2`. If limits are not specified, then the currently set limits apply (See `LinePlotWindow`).

  The parameter `LinePlotDrawLegends` controls the drawing of the legend.

  Examples:

      genius> SlopefieldPlot(`(x,y)=sin(x-y),-5,5,-5,5)

SurfacePlot

      SurfacePlot (func)

      SurfacePlot (func,x1,x2,y1,y2,z1,z2)

      SurfacePlot (func,x1,x2,y1,y2)

      SurfacePlot (func,[x1,x2,y1,y2,z1,z2])

      SurfacePlot (func,[x1,x2,y1,y2])

  Plot a surface function that takes either two arguments or a complex number. First comes the function then optionally limits as `x1`, `x2`, `y1`, `y2`, `z1`, `z2`. If limits are not specified, then the currently set limits apply (See `SurfacePlotWindow`). Genius can only plot a single surface function at this time.

  If the z limits are not specified then the maxima and minima of the function are used.

  Examples:

      genius> SurfacePlot(|sin|,-1,1,-1,1,0,1.5)
      genius> SurfacePlot(`(x,y)=x^2+y,-1,1,-1,1,-2,2)
      genius> SurfacePlot(`(z)=|z|^2,-1,1,-1,1,0,2)

SurfacePlotClear

      SurfacePlotClear ()

  Show the surface plot window and clear out functions and any other lines that were drawn.

  Available in version 1.0.19 and onwards.

SurfacePlotData

      SurfacePlotData (data)

      SurfacePlotData (data,label)

      SurfacePlotData (data,x1,x2,y1,y2,z1,z2)

      SurfacePlotData (data,label,x1,x2,y1,y2,z1,z2)

      SurfacePlotData (data,[x1,x2,y1,y2,z1,z2])

      SurfacePlotData (data,label,[x1,x2,y1,y2,z1,z2])

  Plot a surface from data. The data is an n by 3 matrix whose rows are the x, y and z coordinates. The data can also be simply a vector whose length is a multiple of 3 and so contains the triples of x, y, z. The data should contain at least 3 points.

  Optionally we can give the label and also optionally the limits. If limits are not given, they are computed from the data, `SurfacePlotWindow` is not used, if you want to use it, pass it in explicitly. If label is not given then empty label is used.

  Examples:

      genius> SurfacePlotData([0,0,0;1,0,1;0,1,1;1,1,3])
      genius> SurfacePlotData(data,"My data")
      genius> SurfacePlotData(data,-1,1,-1,1,0,10)
      genius> SurfacePlotData(data,SurfacePlotWindow)

  Here's an example of how to plot in polar coordinates, in particular how to plot the function `-r^2 * theta`:

      genius> d:=null; for r=0 to 1 by 0.1 do for theta=0 to 2*pi by pi/5 do d=[d;[r*cos(theta),r*sin(theta),-r^2*theta]];
      genius> SurfacePlotData(d)

  Version 1.0.16 onwards.

SurfacePlotDataGrid

      SurfacePlotDataGrid (data,[x1,x2,y1,y2])

      SurfacePlotDataGrid (data,[x1,x2,y1,y2,z1,z2])

      SurfacePlotDataGrid (data,[x1,x2,y1,y2],label)

      SurfacePlotDataGrid (data,[x1,x2,y1,y2,z1,z2],label)

  Plot a surface from regular rectangular data. The data is given in a n by m matrix where the rows are the x coordinate and the columns are the y coordinate. The x coordinate is divided into equal n-1 subintervals and y coordinate is divided into equal m-1 subintervals. The limits `x1` and `x2` give the interval on the x-axis that we use, and the limits `y1` and `y2` give the interval on the y-axis that we use. If the limits `z1` and `z2` are not given they are computed from the data (to be the extreme values from the data).

  Optionally we can give the label, if label is not given then empty label is used.

  Examples:

      genius> SurfacePlotDataGrid([1,2;3,4],[0,1,0,1])
      genius> SurfacePlotDataGrid(data,[-1,1,-1,1],"My data")
      genius> d:=null; for i=1 to 20 do for j=1 to 10 do d@(i,j) = (0.1*i-1)^2-(0.1*j)^2;
      genius> SurfacePlotDataGrid(d,[-1,1,0,1],"half a saddle")

  Version 1.0.16 onwards.

SurfacePlotDrawLine

      SurfacePlotDrawLine (x1,y1,z1,x2,y2,z2,...)

      SurfacePlotDrawLine (v,...)

  Draw a line from `x1`,`y1`,`z1` to `x2`,`y2`,`z2`. `x1`,`y1`,`z1`, `x2`,`y2`,`z2` can be replaced by an `n` by 3 matrix for a longer polyline.

  Extra parameters can be added to specify line color, thickness, the plotting window, or legend. You can do this by adding an argument string `"color"`, `"thickness"`, `"window"`, or `"legend"`, and after it specify the color, the thickness, the window as 6-vector, or the legend.

  The color should be either a string indicating the common English word for the color that GTK will recognize such as `"red"`, `"blue"`, `"yellow"`, etc... Alternatively the color can be specified in RGB format as `"#rgb"`, `"#rrggbb"`, or `"#rrrrggggbbbb"`, where the r, g, or b are hex digits of the red, green, and blue components of the color. Finally, since version 1.0.18, the color can also be specified as a real vector specifying the red green and blue components where the components are between 0 and 1, e.g. `[1.0,0.5,0.1]`.

  The window should be given as usual as `[x1,x2,y1,y2,z1,z2]`, or alternatively can be given as a string `"fit"` in which case, the x range will be set precisely and the y range will be set with five percent borders around the line.

  Finally, legend should be a string that can be used as the legend in the graph. That is, if legends are being printed.

  Examples:

      genius> SurfacePlotDrawLine(0,0,0,1,1,1,"color","blue","thickness",3)
      genius> SurfacePlotDrawLine([0,0,0;1,-1,2;-1,-1,-3])

  Available from version 1.0.19 onwards.

SurfacePlotDrawPoints

      SurfacePlotDrawPoints (x,y,z,...)

      SurfacePlotDrawPoints (v,...)

  Draw a point at `x`,`y`,`z`. The input can be an `n` by 3 matrix for `n` different points. This function has essentially the same input as SurfacePlotDrawLine.

  Extra parameters can be added to specify line color, thickness, the plotting window, or legend. You can do this by adding an argument string `"color"`, `"thickness"`, `"window"`, or `"legend"`, and after it specify the color, the thickness, the window as 6-vector, or the legend.

  The color should be either a string indicating the common English word for the color that GTK will recognize such as `"red"`, `"blue"`, `"yellow"`, etc... Alternatively the color can be specified in RGB format as `"#rgb"`, `"#rrggbb"`, or `"#rrrrggggbbbb"`, where the r, g, or b are hex digits of the red, green, and blue components of the color. Finally the color can also be specified as a real vector specifying the red green and blue components where the components are between 0 and 1.

  The window should be given as usual as `[x1,x2,y1,y2,z1,z2]`, or alternatively can be given as a string `"fit"` in which case, the x range will be set precisely and the y range will be set with five percent borders around the line.

  Finally, legend should be a string that can be used as the legend in the graph. That is, if legends are being printed.

  Examples:

      genius> SurfacePlotDrawPoints(0,0,0,"color","blue","thickness",3)
      genius> SurfacePlotDrawPoints([0,0,0;1,-1,2;-1,-1,1])

  Available from version 1.0.19 onwards.

VectorfieldClearSolutions

      VectorfieldClearSolutions ()

  Clears the solutions drawn by the `VectorfieldDrawSolution` function.

  Version 1.0.6 onwards.

VectorfieldDrawSolution

      VectorfieldDrawSolution (x, y, dt, tlen)

  When a vector field plot is active, draw a solution with the specified initial condition. The standard Runge-Kutta method is used with increment `dt` for an interval of length `tlen`. Solutions stay on the graph until a different plot is shown or until you call `VectorfieldClearSolutions`. You can also use the graphical interface to draw solutions and specify initial conditions with the mouse.

  Version 1.0.6 onwards.

VectorfieldPlot

      VectorfieldPlot (funcx, funcy)

      VectorfieldPlot (funcx, funcy, x1, x2, y1, y2)

  Plot a two dimensional vector field. The function `funcx` should be the dx/dt of the vectorfield and the function `funcy` should be the dy/dt of the vectorfield. The functions should take two real numbers `x` and `y`, or a single complex number. When the parameter `VectorfieldNormalized` is `true`, then the magnitude of the vectors is normalized. That is, only the direction and not the magnitude is shown.

  Optionally you can specify the limits of the plotting window as `x1`, `x2`, `y1`, `y2`. If limits are not specified, then the currently set limits apply (See `LinePlotWindow`).

  The parameter `LinePlotDrawLegends` controls the drawing of the legend.

  Examples:

      genius> VectorfieldPlot(`(x,y)=x^2-y, `(x,y)=y^2-x, -1, 1, -1, 1)

## Примеры программ на GEL

Here is a function that calculates factorials:

    function f(x) = if x <= 1 then 1 else (f(x-1)*x)

With indentation it becomes:

    function f(x) = (
      if x <= 1 then
        1
      else
        (f(x-1)*x)
    )

This is a direct port of the factorial function from the bc manpage. The syntax seems similar to bc, but different in that in GEL, the last expression is the one that is returned. Using the `return` function instead, it would be:

    function f(x) = (
      if (x <= 1) then return (1);
      return (f(x-1) * x)
    )

By far the easiest way to define a factorial function would be using the product loop as follows. This is not only the shortest and fastest, but also probably the most readable version.

    function f(x) = prod k=1 to x do k

Here is a larger example, this basically redefines the internal `ref` function to calculate the row echelon form of a matrix. The function `ref` is built in and much faster, but this example demonstrates some of the more complex features of GEL.

    # Calculate the row-echelon form of a matrix
    function MyOwnREF(m) = (
      if not IsMatrix(m) or not IsValueOnly(m) then
        (error("MyOwnREF: argument not a value only matrix");bailout);
      s := min(rows(m), columns(m));
      i := 1;
      d := 1;
      while d <= s and i <= columns(m) do (

        # This just makes the anchor element non-zero if at
        # all possible
        if m@(d,i) == 0 then (
          j := d+1;
          while j <= rows(m) do (
            if m@(j,i) == 0 then
              (j=j+1;continue);
            a := m@(j,);
            m@(j,) := m@(d,);
            m@(d,) := a;
            j := j+1;
            break
          )
        );
        if m@(d,i) == 0 then
          (i:=i+1;continue);

        # Here comes the actual zeroing of all but the anchor
        # element rows
        j := d+1;
        while j <= rows(m)) do (
          if m@(j,i) != 0 then (
            m@(j,) := m@(j,)-(m@(j,i)/m@(d,i))*m@(d,)
          );
          j := j+1
        );
        m@(d,) := m@(d,) * (1/m@(d,i));
        d := d+1;
        i := i+1
      );
      m
    )

## Настройки

To configure Genius Mathematics Tool, choose Settings Preferences. There are several basic parameters provided by the calculator in addition to the ones provided by the standard library. These control how the calculator behaves.

### Changing Settings with GEL

Many of the settings in Genius are simply global variables, and can be evaluated and assigned to in the same way as normal variables. See about evaluating and assigning to variables, and for a list of settings that can be modified in this way.

As an example, you can set the maximum number of digits in a result to 12 by typing:

    MaxDigits = 12

### Output

Maximum digits to output

  The maximum digits in a result (`MaxDigits`)

Results as floats

  If the results should be always printed as floats (`ResultsAsFloats`)

Floats in scientific notation

  If floats should be in scientific notation (`ScientificNotation`)

Always print full expressions

  Should we print out full expressions for non-numeric return values (longer than a line) (`FullExpressions`)

Use mixed fractions

  If fractions should be printed as mixed fractions such as "1 1/3" rather than "4/3". (`MixedFractions`)

Display 0.0 when floating point number is less than 10^-x (0=never chop)

  How to chop output. But only when other numbers nearby are large. See the documentation of the parameter `OutputChopExponent`.

Only chop numbers when another number is greater than 10^-x

  When to chop output. This is set by the parameter `OutputChopWhenExponent`. See the documentation of the parameter `OutputChopExponent`.

Remember output settings across sessions

  Should the output settings in the Number/Expression output options frame be remembered for next session. Does not apply to the Error/Info output options frame.

  If unchecked, either the default or any previously saved settings are used each time Genius starts up. Note that settings are saved at the end of the session, so if you wish to change the defaults check this box, restart Genius Mathematics Tool and then uncheck it again.

Display errors in a dialog

  If set the errors will be displayed in a separate dialog, if unset the errors will be printed on the console.

Display information messages in a dialog

  If set the information messages will be displayed in a separate dialog, if unset the information messages will be printed on the console.

Maximum errors to display

  The maximum number of errors to return on one evaluation (`MaxErrors`). If you set this to 0 then all errors are always returned. Usually if some loop causes many errors, then it is unlikely that you will be able to make sense out of more than a few of these, so seeing a long list of errors is usually not helpful.

In addition to these preferences, there are some preferences that can only be changed by setting them in the workspace console. For others that may affect the output see .

`IntegerOutputBase`

  The base that will be used to output integers

`OutputStyle`

  A string, can be `"normal"`, `"latex"`, `"mathml"` or `"troff"` and it will affect how matrices (and perhaps other stuff) is printed, useful for pasting into documents. Normal style is the default human readable printing style of Genius Mathematics Tool. The other styles are for typesetting in LaTeX, MathML (XML), or in Troff.

### Precision

Floating point precision

  The floating point precision in bits (`FloatPrecision`). Note that changing this only affects newly computed quantities. Old values stored in variables are obviously still in the old precision and if you want to have them more precise you will have to recompute them. Exceptions to this are the system constants such as `pi` or `e`.

Remember precision setting across sessions

  Should the precision setting be remembered for the next session. If unchecked, either the default or any previously saved setting is used each time Genius starts up. Note that settings are saved at the end of the session, so if you wish to change the default check this box, restart genius and then uncheck it again.

### Терминал

Терминалом называется консоль в рабочей области.

Scrollback lines

  Lines of scrollback in the terminal.

Font

  Шрифт, используемый в терминале

Black on white

  Использовать в терминале чёрный текст на белом фоне.

Blinking cursor

  Должен ли курсор терминала мигать, если фокус ввода находится в терминале. Иногда это раздражает, кроме того это создаёт лишний трафик при удалённом доступе к Genius.

### Память

Maximum number of nodes to allocate

  Internally all data is put onto small nodes in memory. This gives a limit on the maximum number of nodes to allocate for computations. This limit avoids the problem of running out of memory if you do something by mistake that uses too much memory, such as a recursion without end. This could slow your computer and make it hard to even interrupt the program.

  Once the limit is reached, Genius Mathematics Tool asks if you wish to interrupt the computation or if you wish to continue. If you continue, no limit is applied and it will be possible to run your computer out of memory. The limit will be applied again next time you execute a program or an expression on the Console regardless of how you answered the question.

  Setting the limit to zero means there is no limit to the amount of memory that genius uses.

## О математическом инструменте Genius

Математический инструмент Genius создан Jiří (George) Lebl (jirka@5z.com). История математического инструмента Genius началась в конце 1997 г. Это был первый калькулятор для GNOME, но с тех пор он вырос в нечто большее, чем простой настольный калькулятор. Чтобы узнать больше о математическом инструменте Genius, посетите веб-страницу Genius.

To report a bug or make a suggestion regarding this application or this manual, send email to me (the author) or post to the mailing list (see the web page).

This program is distributed under the terms of the GNU General Public license as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. A copy of this license can be found at this link, or in the file COPYING included with the source code of this program.

Jiří Lebl was during various parts of the development partially supported for the work by NSF grants DMS 0900885, DMS 1362337, the University of Illinois at Urbana-Champaign, the University of California at San Diego, the University of Wisconsin-Madison, and Oklahoma State University. The software has been used for both teaching and research.