<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE book PUBLIC "-//OASIS//DTD DocBook XML V4.1.2//EN" "http://www.oasis-open.org/docbook/xml/4.1.2/docbookx.dtd" [
<!ENTITY app "<application>Genius Mathematics Tool</application>">
<!ENTITY appname "Genius">
<!ENTITY appversion "1.0.27">
<!ENTITY date "October 2021">
<!ENTITY legal SYSTEM "legal.xml">
<!ENTITY manrevision "0.2">
<!ENTITY lt "&#60;">
<!ENTITY gt "&#62;">
<!ENTITY le "&#8804;">
<!ENTITY ge "&#8805;">
<!ENTITY lsquo "&#8216;">
<!ENTITY rsquo "&#8217;">
<!--<!ENTITY gel-function-list SYSTEM "gel-function-list.xml">-->]>
<!-- 
      (Do not remove this comment block.)
  Maintained by the GNOME Documentation Project
  http://developer.gnome.org/projects/gdp
  Template version: 2.0 beta
  Template last modified Apr 11, 2002
-->
<!-- =============Document Header ============================= -->
<book id="index" lang="messages">
<!-- please do not change the id; for translations, change lang to -->
<!-- appropriate code -->
  <bookinfo>
	  <abstract role="description"><para>Руководство по Математическому инструменту Genius.</para></abstract>
    <title>Руководство пользователя Genius</title>       

    <copyright lang="en">
      <year>1997-2021</year>
      <holder>Jiří (George) Lebl</holder>
    </copyright>
    <copyright lang="en">
      <year>2004</year>
      <holder>Kai Willadsen</holder>
    </copyright>
<!-- translators: uncomment this:
  <copyright>
   <year>2002</year>
   <holder>ME-THE-TRANSLATOR (Latin translation)</holder>
  </copyright>
-->

    <publisher> 
      <publishername/> 
    </publisher> 

     <legalnotice id="legalnotice">
	<para lang="en">
	  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 <ulink type="help" url="ghelp:fdl">link</ulink> or in the file COPYING-DOCS
	  distributed with this manual.
         </para>
         <para lang="en"> 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.
	</para>

	<para lang="en">
	  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.
	</para>

	<para lang="en">
	  DOCUMENT AND MODIFIED VERSIONS OF THE DOCUMENT ARE PROVIDED
	  UNDER  THE TERMS OF THE GNU FREE DOCUMENTATION LICENSE
	  WITH THE FURTHER UNDERSTANDING THAT:

	  <orderedlist>
		<listitem>
		  <para lang="en">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
		  </para>
		</listitem>
		<listitem>
		  <para lang="en">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.
		  </para>
		</listitem>
	  </orderedlist>
	</para>
  </legalnotice>


   <!-- This file  contains link to license for the documentation (GNU FDL), and 
        other legal stuff such as "NO WARRANTY" statement. Please do not change 
	any of this. -->

    <authorgroup> 
      <author role="maintainer" lang="en"> 
		<firstname>Jiří</firstname> 
		<surname>Lebl</surname> 
		<affiliation> 
	  		<orgname>Oklahoma State University</orgname> 
	  		<address> <email>jiri.lebl@gmail.com</email> </address> 
		</affiliation> 
      </author> 
      <author lang="en"> 
		<firstname>Kai</firstname> 
		<surname>Willadsen</surname> 
		<affiliation> 
	  		<orgname>University of Queensland, Australia</orgname> 
	  		<address> <email>kaiw@itee.uq.edu.au</email> </address> 
		</affiliation> 
      </author> 
      
<!-- This is appropriate place for other contributors: translators,
     maintainers,  etc. Commented out by default.
     
      <othercredit role="translator">
		<firstname>Latin</firstname> 
		<surname>Translator 1</surname> 
		<affiliation> 
	  		<orgname>Latin Translation Team</orgname> 
	  		<address> <email>translator@gnome.org</email> </address> 
		</affiliation>
		<contrib>Latin translation</contrib>
      </othercredit>
-->
    </authorgroup>


<!-- According to GNU FDL, revision history is mandatory if you are -->
<!-- modifying/reusing someone else's document.  If not, you can omit it. -->
<!-- Remember to remove the &manrevision; entity from the revision entries other
-->
<!-- than the current revision. -->
<!-- The revision numbering system for GNOME manuals is as follows: -->
<!-- * the revision number consists of two components -->
<!-- * the first component of the revision number reflects the release version of the GNOME desktop. -->
<!-- * the second component of the revision number is a decimal unit that is incremented with each revision of the manual. -->
<!-- For example, if the GNOME desktop release is V2.x, the first version of the manual that -->
<!-- is written in that desktop timeframe is V2.0, the second version of the manual is V2.1, etc. -->
<!-- When the desktop release version changes to V3.x, the revision number of the manual changes -->
<!-- to V3.0, and so on. -->  
<!--  This is unmaintained quite a bit so screw this it just makes things
      ugly and we don't update the manrevision stuff anyway
    <revhistory>
      <revision> 
		<revnumber>&manrevision;</revnumber> 
		<date>&date;</date> 
		<revdescription> 
	  		<para role="author">Jiri (George) Lebl
	    	<email>jirka@5z.com</email>
	  		</para>
		</revdescription> 
      </revision> 
      <revision> 
		<revnumber>0.1</revnumber> 
		<date>September 2004</date> 
		<revdescription> 
	  		<para role="author">Kai Willadsen
	    	<email>kaiw@itee.uq.edu.au</email>
	  		</para>
		</revdescription> 
      </revision> 
      <revision> 
		<revnumber>Genius Calculator Manual</revnumber> 
		<date>August 2004</date> 
		<revdescription> 
	  		<para role="author">Jiri (George) Lebl
	    	<email>jiri.lebl@gmail.com</email>
	  		</para>
		</revdescription> 
      </revision> 
    </revhistory> 
-->

    <revhistory>
      <revision lang="en"> 
		<revnumber>0.2</revnumber> 
		<date>October 2021</date> 
		<revdescription> 
	  		<para role="author" lang="en">Jiri (George) Lebl
	    	<email>jiri.lebl@gmail.com</email>
	  		</para>
		</revdescription> 
      </revision> 
    </revhistory>
    <releaseinfo lang="en">This manual describes version 1.0.27 of Genius.
    </releaseinfo> 
    <legalnotice> 
      <title>Обратная связь</title> 
      <para lang="en">
	      To report a bug or make a suggestion regarding the <application>Genius Mathematics Tool</application>
	      application or this manual, please visit the
	      <ulink url="http://www.jirka.org/genius.html" type="http">Genius
		      Web page</ulink>
	      or email me at <email>jiri.lebl@gmail.com</email>.
      </para>
<!-- Translators may also add here feedback address for translations -->
    </legalnotice> 
  </bookinfo> 

<!-- ============= Introduction =============================== -->
  <chapter id="genius-introduction"> 
    <title>Введение</title> 
    <para lang="en">
	The <application>Genius Mathematics Tool</application> 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 <application>Genius Mathematics Tool</application> 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.  <application>Genius Mathematics Tool</application> 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.
    </para> 

    <para lang="en">
	<application>Genius Mathematics Tool</application> 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
    </para> 

    <para lang="en">
	    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.
    </para>

    <para lang="en">
	    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.
    </para>

  </chapter>

<!-- =========== Getting Started ============================== -->
  <chapter id="genius-getting-started"> 
    <title>Приступая к работе</title> 

    <sect1 id="genius-to-start">
      <title>Запуск <application>Математического инструмента Genius</application></title>
      <para lang="en">You can start <application>Genius Mathematics Tool</application> in the following ways:
      </para> 
      <variablelist>
        <varlistentry>
          <term>Меню <guimenu>Приложения</guimenu></term>
          <listitem>
	    <para>В зависимости от установленной операционной системы и её версии, команда меню для запуска <application>Математического инструмента Genius</application> может находиться в различных местах. Она может располагаться в подменю <guisubmenu>Образование</guisubmenu>, <guisubmenu>Стандартные</guisubmenu>, <guisubmenu>Офис</guisubmenu>, <guisubmenu>Наука</guisubmenu> или других подобных подменю. Нужный вам элемент меню называется <guimenuitem>Математический инструмент Genius</guimenuitem>. Когда вы найдёте этот элемент меню, щёлкните на нём, чтобы запустить <application>Математический инструмент Genius</application>.</para>
	      </listitem>
        </varlistentry>
        <varlistentry>
          <term>Диалог запуска</term>
          <listitem>
	    <para>В некоторых операционных системах упомянутая выше команда меню может быть недоступна. В этом случае можно открыть диалог запуска и выполнить команду <command>gnome-genius</command>.</para>
	      </listitem>
        </varlistentry>
        <varlistentry>
    	  <term>Командная строка</term>
    	  <listitem>
    	    <para>Чтобы запустить версию <application>Математического инструмента Genius</application> для GNOME, выполните в командной строке <command>gnome-genius</command>.</para>
	    <para>Чтобы запустить версию для командной строки, выполните следующую команду: <command>genius</command>. Эта версия не содержит графического интерфейса и некоторые возможности, такие как построение графиков, будут в ней недоступны.</para> 
          </listitem>
        </varlistentry>
      </variablelist>
    </sect1>

    <sect1 id="genius-when-start">
    <title>После запуска Genius</title>
      <para>После запуска версии <application>Математического инструмента Genius</application> для GNOME появится окно, изображённое на иллюстрации <xref linkend="mainwindow-fig"/>.</para>

      <figure id="mainwindow-fig"> 
        <title>Окно <application>Математического инструмента Genius</application></title> 
        <screenshot> 
          <mediaobject lang="en"> 
            <imageobject>
              <imagedata fileref="figures/genius_window.png" format="PNG" scalefit="1"/> 
            </imageobject>
            <textobject> 
	      <phrase>Shows <application>Genius Mathematics Tool</application> main window. Contains titlebar, menubar,
toolbar and working area. Menubar contains <guilabel>File</guilabel>,
<guilabel>Edit</guilabel>, <guilabel>Calculator</guilabel>,
<guilabel>Examples</guilabel>,
<guilabel>Programs</guilabel>,
<guilabel>Settings</guilabel>, and <guilabel>Help</guilabel> menus.</phrase> 
            </textobject> 
          </mediaobject>
        </screenshot> 
      </figure>

      <para>Окно <application>Математического инструмента Genius</application> содержит следующие элементы:</para>
      <variablelist>
        <varlistentry>
          <term>Строка меню.</term>
          <listitem>
            <para>Строка меню содержит все команды, необходимые для работы с файлами в <application>Математическом инструменте Genius</application>. Меню <guilabel>Файл</guilabel> содержит команды для загрузки и сохранения объектов и создания новых программ. Команда <guilabel>Загрузить и выполнить...</guilabel> не открывает новое окно для программы, а просто сразу выполняет программу. Её действие эквивалентно действию команды <command>load</command>.</para>
	    <para lang="en">
		The <guilabel>Calculator</guilabel> 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 <guilabel>Calculator</guilabel> allows plotting functions using a user friendly dialog box.
	   </para>
	   <para lang="en">
		   The <guilabel>Examples</guilabel> 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 <application>Genius Mathematics Tool</application>
		   or some mathematical concept.
	   </para>
	   <para lang="en">
		   The <guilabel>Programs</guilabel> menu lists
		   the currently open programs and allows you to switch
		   between them.
	   </para>
	   <para>Остальные меню выполняют такие же действия, как в других приложениях.</para>
          </listitem>
        </varlistentry>
        <varlistentry>
          <term>Панель инструментов.</term>
          <listitem>
            <para>Панель инструментов содержит некоторые из команд, к которым можно получить доступ через строку меню.</para>
          </listitem>
        </varlistentry>
        <varlistentry>
          <term>Рабочая область</term>
          <listitem>
            <para>Рабочая область — основной способ взаимодействия с приложением.</para>
	    <para lang="en">
	    	The working area initially has just the <guilabel>Console</guilabel> 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.
	    </para>
	    <para lang="en">
	    	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.
	    </para>
          </listitem>
        </varlistentry>
      </variablelist>
    </sect1>

  </chapter>

<!-- ================ Usage =================================== -->
  <chapter id="genius-usage"> 
    <title>Основы работы с программой</title> 

    <sect1 id="genius-usage-workarea"> 
      <title>Использование рабочей области</title> 

      <para lang="en">
        Normally you interact with the calculator in the <guilabel>Console</guilabel> 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
	<application>Genius Mathematics Tool</application> as a calculator only, just type in your expression in the console, it
	will be evaluated, and the returned value will be printed.
      </para>

      <para lang="en">
	      To evaluate an expression, type it into the <guilabel>Console</guilabel> work area and press enter.
	      Expressions are written in a
language called GEL.  The most simple GEL expressions just looks like
mathematics.  For example
<screen lang="en"><prompt>genius&gt; </prompt><userinput>30*70 + 67^3.0 + ln(7) * (88.8/100)</userinput>
</screen>
or
<screen lang="en"><prompt>genius&gt; </prompt><userinput>62734 + 812634 + 77^4 mod 5</userinput>
</screen>
or
<screen lang="en"><prompt>genius&gt; </prompt><userinput>| sin(37) - e^7 |</userinput>
</screen>
or
<screen lang="en"><prompt>genius&gt; </prompt><userinput>sum n=1 to 70 do 1/n</userinput>
</screen>
(Last is the harmonic sum from 1 to 70)
</para>
<para lang="en">
To get a list of functions and commands, type:
<screen lang="en"><prompt>genius&gt; </prompt><userinput>help</userinput>
</screen>
If you wish to get more help on a specific function, type:
<screen lang="en"><prompt>genius&gt; </prompt><userinput>help FunctionName</userinput>
</screen>
To view this manual, type:
<screen lang="en"><prompt>genius&gt; </prompt><userinput>manual</userinput>
</screen>
</para>
<para lang="en">
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 <filename>path/to/program.gel</filename>,
type
<screen lang="en"><prompt>genius&gt; </prompt><userinput>load path/to/program.gel</userinput>
</screen>
<application>Genius Mathematics Tool</application> keeps track of the current directory.
To list files in the current directory type <command>ls</command>, to change directory
do <userinput>cd directory</userinput> as in the UNIX command shell.
</para>
    </sect1>

    <sect1 id="genius-usage-create-program"> 
      <title>Создание новой программы</title> 
      <para lang="en">
	      If you wish to enter several more complicated commands, or perhaps write a complicated
	      function using the <link linkend="genius-gel">GEL</link> language, you can create a new
	     program; really just a file with many commands.
      </para>
      <para lang="en">
To start writing a new program, choose
<menuchoice><guimenu>File</guimenu><guimenuitem>New
Program</guimenuitem></menuchoice>. A new tab will appear in the work area. You
can write a <link linkend="genius-gel">GEL</link> program in this work area.
Once you have written your program you can run it by 
<menuchoice><guimenu>Calculator</guimenu><guimenuitem>Run</guimenuitem></menuchoice> (or
the <guilabel>Run</guilabel> toolbar button).
This will execute your program and will display any output on the <guilabel>Console</guilabel> 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.
<menuchoice><guimenu>Calculator</guimenu><guimenuitem>Run</guimenuitem></menuchoice>
will always run the currently selected program even if you are on the <guilabel>Console</guilabel>
tab.  The currently selected program has its tab in bold type.  To select a
program, just click on its tab.
      </para>
      <para lang="en">
To save the program you've just written, choose <menuchoice><guimenu>File</guimenu><guimenuitem>Save As...</guimenuitem></menuchoice>.
Similarly as in other programs you can choose
<menuchoice><guimenu>File</guimenu><guimenuitem>Save</guimenuitem></menuchoice> 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
<menuchoice><guimenu>File</guimenu><guimenuitem>Save All Unsaved</guimenuitem></menuchoice>.
      </para>
      <para lang="en">
	      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.
      </para>
    </sect1>

    <sect1 id="genius-usage-open-program"> 
      <title>Открытие и запуск программы</title> 
      <para>Чтобы открыть файл, выберите <menuchoice><guimenu>Файл</guimenu><guimenuitem>Открыть</guimenuitem></menuchoice>. В рабочей области появится новая вкладка с содержимым файла. Вы можете использовать её для редактирования файла.</para>
      <para>Чтобы запустить программу из файла, выберите <menuchoice><guimenu>Файл</guimenu><guimenuitem>Загрузить и выполнить...</guimenuitem></menuchoice>. Это действие запустит программу, не открывая её в отдельной вкладке. Это эквивалентно команде <command>load</command>.</para>
      <para lang="en">
	      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
	      <menuchoice><guimenu>File</guimenu><guimenuitem>Reload from Disk</guimenuitem></menuchoice> 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.
      </para>
    </sect1>

  </chapter>

  <!-- ============= Plotting ============================== -->
  <chapter id="genius-gel-plotting">
    <title>Построение графиков</title>

    <para>Построение графиков поддерживается только в версии с графическим интерфейсом для GNOME. Все варианты графиков, имеющиеся в графическом интерфейсе, доступны из окна <guilabel>Создать график</guilabel>. Чтобы открыть это окно, нажмите кнопку <guilabel>График</guilabel> на панели инструментов или выберите <guilabel>Нарисовать график</guilabel> из меню <guilabel>Калькулятор</guilabel>. Можно также использовать команды <link linkend="genius-gel-function-list-plotting">построения графиков</link> языка GEL. Смотрите <xref linkend="genius-gel"/>, чтобы узнать, как вводить выражения, которые понимает Genius.</para>

    <sect1 id="genius-line-plots">
      <title>Линейные графики</title>
      <para lang="en">
	To graph real-valued functions of one variable, open the <guilabel>Create Plot</guilabel>
	window.  You can also use the
        <link linkend="gel-function-LinePlot"><function>LinePlot</function></link> 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.
      </para>
      <para>После нажатия кнопки <guilabel>График</guilabel> откроется окно с несколькими вкладками. Вам нужна вкладка <guilabel>Линейный график функции</guilabel>, внутри которой следует выбрать вкладку <guilabel>Функции / Выражения</guilabel>. Смотрите <xref linkend="lineplot-fig"/>.</para>

      <figure id="lineplot-fig"> 
        <title lang="en">Create Plot Window</title> 
        <screenshot> 
          <mediaobject lang="en"> 
            <imageobject>
              <imagedata fileref="figures/line_plot.png" format="PNG" scalefit="1"/> 
            </imageobject>
            <textobject> 
              <phrase>Shows the line plotting window.</phrase> 
            </textobject> 
          </mediaobject> 
        </screenshot> 
      </figure>

      <para lang="en">
	Type expressions with <userinput>x</userinput> as
	the independent variable into the textboxes.  Alternatively you can give names of functions such as
	<userinput>cos</userinput> rather then having to type <userinput>cos(x)</userinput>.
	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 <userinput>2*pi</userinput> or <userinput>10^3</userinput>.
	The <varname>y</varname> (dependent) range can be set automatically by turning on the <guilabel>Fit dependent axis</guilabel>
	checkbox.
	The names of the variables can also be changed.
	Pressing the <guilabel>Plot</guilabel> button produces the graph shown in <xref linkend="lineplot2-fig"/>.
      </para>
      <para lang="en">
	      The variables can be renamed by clicking the <guilabel>Change variable names...</guilabel> 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.
      </para>

      <figure id="lineplot2-fig"> 
        <title lang="en">Plot Window</title> 
        <screenshot> 
          <mediaobject lang="en"> 
            <imageobject>
              <imagedata fileref="figures/line_plot_graph.png" format="PNG" scalefit="1"/> 
            </imageobject>
            <textobject> 
              <phrase>The graph produced.</phrase> 
            </textobject> 
          </mediaobject> 
        </screenshot> 
      </figure>

      <para lang="en">
	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.
      </para>

      <para lang="en">
	For plotting using the command line see the documentation of the
        <link linkend="gel-function-LinePlot"><function>LinePlot</function></link> function.
      </para>
    </sect1>

    <sect1 id="genius-parametric-plots">
      <title lang="en">Parametric Plots</title>
      <para lang="en">
	In the create plot window, you can also choose the <guilabel>Parametric</guilabel> notebook
        tab to create two dimensional parametric plots.  This way you can
	plot a single parametric function.  You can either specify the
	points as <varname>x</varname> and <varname>y</varname>, or giving a single complex number
	as a function of the variable <varname>t</varname>.
	The range of the variable <varname>t</varname> is given explicitly, and the function is sampled
	according to the given increment.
	The <varname>x</varname> and <varname>y</varname> range can be set
	automatically by turning on the <guilabel>Fit dependent axis</guilabel>
	checkbox, or it can be specified explicitly.
	See <xref linkend="paramplot-fig"/>.
      </para>

      <figure id="paramplot-fig"> 
        <title lang="en">Parametric Plot Tab</title> 
        <screenshot> 
          <mediaobject lang="en"> 
            <imageobject>
              <imagedata fileref="figures/parametric.png" format="PNG" scalefit="1"/> 
            </imageobject>
            <textobject> 
              <phrase>Parametric plotting tab in the <guilabel>Create Plot</guilabel> window.</phrase> 
            </textobject> 
          </mediaobject> 
        </screenshot> 
      </figure>

      <para lang="en">
	An example of a parametric plot is given in
	<xref linkend="paramplot2-fig"/>.
	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
        <link linkend="gel-function-LinePlotParametric"><function>LinePlotParametric</function></link> or
        <link linkend="gel-function-LinePlotCParametric"><function>LinePlotCParametric</function></link> function.
      </para>

      <figure id="paramplot2-fig"> 
        <title lang="en">Parametric Plot</title> 
        <screenshot> 
          <mediaobject lang="en"> 
            <imageobject>
              <imagedata fileref="figures/parametric_graph.png" format="PNG" scalefit="1"/> 
            </imageobject>
            <textobject> 
              <phrase>Parametric plot produced</phrase> 
            </textobject> 
          </mediaobject> 
        </screenshot> 
      </figure>

    </sect1>

    <sect1 id="genius-slopefield-plots">
      <title lang="en">Slopefield Plots</title>
      <para lang="en">
	In the create plot window, you can also choose the <guilabel>Slope field</guilabel> 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
        <link linkend="gel-function-SlopefieldPlot"><function>SlopefieldPlot</function></link> function.
      </para>

      <para lang="en">
	When a slope field is active, there is an extra <guilabel>Solver</guilabel> 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.
      </para>

      <para lang="en">
	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
        <link linkend="gel-function-SlopefieldDrawSolution"><function>SlopefieldDrawSolution</function></link>
	function to draw solutions from the command line or programs.  
      </para>

    </sect1>

    <sect1 id="genius-vectorfield-plots">
      <title lang="en">Vectorfield Plots</title>
      <para lang="en">
	In the create plot window, you can also choose the <guilabel>Vector field</guilabel> 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
        <link linkend="gel-function-VectorfieldPlot"><function>VectorfieldPlot</function></link> function.
      </para>

      <para lang="en">
	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.
      </para>

      <para lang="en">
	When a vector field is active, there is an extra <guilabel>Solver</guilabel> 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.
      </para>

      <para lang="en">
	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
        <link linkend="gel-function-VectorfieldDrawSolution"><function>VectorfieldDrawSolution</function></link>
	function to draw solutions from the command line or programs.  
      </para>

    </sect1>

    <sect1 id="genius-surface-plots">
      <title>Графики поверхностей</title>
      <para lang="en">
	Genius can also plot surfaces.  Select the <guilabel>Surface plot</guilabel> tab in the
	main notebook of the <guilabel>Create Plot</guilabel> window.  Here you can specify a single
	expression that should use either <varname>x</varname> and <varname>y</varname> as real independent variables
	or <varname>z</varname> as a complex variable (where <varname>x</varname> is the real part of <varname>z</varname> and <varname>y</varname> is the
	imaginary part).  For example to plot the modulus of the cosine
	function for complex parameters,
	you could enter <userinput>|cos(z)|</userinput>.  This would be
	equivalent to <userinput>|cos(x+1i*y)|</userinput>.
	See <xref linkend="surfaceplot-fig"/>.
	For plotting using the command line see the documentation of the
        <link linkend="gel-function-SurfacePlot"><function>SurfacePlot</function></link> function.
      </para>
      <para lang="en">
	      The <varname>z</varname> range can be set automatically by turning on the <guilabel>Fit dependent axis</guilabel>
	      checkbox.  The variables can be renamed by clicking the <guilabel>Change variable names...</guilabel> 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.
      </para>

      <figure id="surfaceplot-fig"> 
        <title lang="en">Surface Plot</title> 
        <screenshot> 
          <mediaobject lang="en"> 
            <imageobject>
              <imagedata fileref="figures/surface_graph.png" format="PNG" scalefit="1"/> 
            </imageobject>
            <textobject> 
              <phrase>Modulus of the complex cosine function.</phrase> 
            </textobject> 
          </mediaobject> 
        </screenshot> 
      </figure>

      <para lang="en">
	      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 <guilabel>Rotate axis...</guilabel> in the <guilabel>View</guilabel> 
	      menu.  The <guilabel>View</guilabel> 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 <guilabel>Start rotate animation</guilabel>, to start a continuous slow rotation.
	      This is especially good if using <application>Genius Mathematics Tool</application> to present to an audience.
      </para>

    </sect1>

  </chapter>

  <!-- ============= GEL ====================================== -->
  <chapter id="genius-gel"> 
    <title>Основы GEL</title> 

	<para lang="en">
	  GEL stands for Genius Extension Language.  <!-- Alternatively it also
	  stands for George's Ego Leverage. -->  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.
	  <application>Genius Mathematics Tool</application> 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.
	</para>

    <sect1 id="genius-gel-values">
      <title>Значения</title>

      <para lang="en">
	      Values in GEL can be <link linkend="genius-gel-values-numbers">numbers</link>, <link linkend="genius-gel-values-booleans">Booleans</link>, or <link linkend="genius-gel-values-strings">strings</link>.   GEL also treats 
<link linkend="genius-gel-matrices">matrices</link> as values.
	      Values can be used in calculations, assigned to variables and returned from functions, among other uses.
      </para>

      <sect2 id="genius-gel-values-numbers">
        <title>Числа</title>
        <para lang="en">
Integers are the first type of number in GEL. Integers are written in the normal way.
<programlisting lang="en">1234
</programlisting>
Hexadecimal and octal numbers can be written using C notation. For example:
<programlisting lang="en">0x123ABC
01234
</programlisting>
Or you can type numbers in an arbitrary base using <literal>&lt;base&gt;\&lt;number&gt;</literal>. Digits higher than 10 use letters in a similar way to hexadecimal. For example, a number in base 23 could be written:
<programlisting lang="en">23\1234ABCD
</programlisting>
        </para>

        <para lang="en">
The second type of GEL number is rationals. Rationals are simply achieved by dividing two integers. So one could write:
<programlisting lang="en">3/4
</programlisting>
to get three quarters. Rationals also accept mixed fraction notation. So in order to get one and three tenths you could write:
<programlisting lang="en">1 3/10
</programlisting>
        </para>

        <para lang="en">
The next type of number is floating point. These are entered in a similar fashion to C notation. You can use <literal>E</literal>, <literal>e</literal> or <literal>@</literal> as the exponent delimiter. Note that using the exponent delimiter gives a float even if there is no decimal point in the number. Examples:
<programlisting lang="en">1.315
7.887e77
7.887e-77
.3
0.3
77e5
</programlisting>
	When Genius prints a floating point number it will always append a
	<computeroutput>.0</computeroutput> 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 <computeroutput>.0</computeroutput>.
        </para>

        <para lang="en">
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 <literal>i</literal>.  Here are examples of entering complex numbers:
<programlisting lang="en">1+2i
8.01i
77*e^(1.3i)
</programlisting>
        </para>

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

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

      </sect2>


      <sect2 id="genius-gel-values-booleans">
        <title>Логические значения</title>
        <para>Genius также поддерживает логические значения. Определены две логические константы: <constant>true</constant> и <constant>false</constant>; их можно использовать, как и любую переменную. В качестве псевдонимов к ним можно также использовать <constant>True</constant>, <constant>TRUE</constant>, <constant>False</constant> и <constant>FALSE</constant>.</para>
        <para>Там, где требуется логическое выражение, можно использовать логическое значение или любое выражение, дающее в результате число или логическое значение. Если Genius нужно использовать число как логическое значение, он будет интерпретировать 0 как <constant>false</constant> и любое другое число как <constant>true</constant>.</para>
        <para lang="en">
In addition, you can do arithmetic with Boolean values. For example:
<programlisting lang="en">( (1 + true) - false ) * true
</programlisting>
is the same as:
<programlisting lang="en">( (true or true) or not false ) and true
</programlisting>
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:
<programlisting lang="en">1 == true
</programlisting>
always evaluates to <constant>true</constant> since 1 will be converted to <constant>true</constant> before being compared to <constant>true</constant>.
        </para>
      </sect2>


      <sect2 id="genius-gel-values-strings">
        <title>Строки</title>
        <para lang="en">
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:
<programlisting lang="en">a=2+3;"The result is: "+a
</programlisting>
will create the string:
<programlisting lang="en">The result is: 5
</programlisting>
You can also use C-like escape sequences such as <literal>\n</literal>,<literal>\t</literal>,<literal>\b</literal>,<literal>\a</literal> and <literal>\r</literal>. To get a <literal>\</literal> or <literal>"</literal> into the string you can quote it with a <literal>\</literal>. For example:
<programlisting lang="en">"Slash: \\ Quotes: \" Tabs: \t1\t2\t3"
</programlisting>
will make a string:
<programlisting lang="en">Slash: \ Quotes: " Tabs: 	1	2	3
</programlisting>
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 
<link linkend="gel-function-print"><function>print</function></link>
or
<link linkend="gel-function-printn"><function>printn</function></link> functions.
        </para>
        <para lang="en">
		In addition, you can use the library function <link linkend="gel-function-string"><function>string</function></link> to convert anything to a string. For example:
<programlisting lang="en">string(22)
</programlisting>
will return
<programlisting lang="en">"22"
</programlisting>
Strings can also be compared with <literal>==</literal> (equal), <literal>!=</literal> (not equal) and <literal>&lt;=&gt;</literal> (comparison) operators
        </para>
      </sect2>


      <sect2 id="genius-gel-values-null">
        <title>Null</title>
        <para lang="en">
There is a special value called
<constant>null</constant>. No operations can be performed on
it, and nothing is printed when it is returned. Therefore,
<constant>null</constant> is useful when you do not want output from an
expression.  The value <constant>null</constant> can be obtained as an expression when you
type <literal>.</literal>, the constant <constant>null</constant> or nothing.
By nothing we mean that if you end an expression with
a separator <literal>;</literal>, it is equivalent to ending it with a
separator followed by a <constant>null</constant>.
        </para>
        <para lang="en">
Example:
<programlisting lang="en">x=5;.
x=5;
</programlisting>
        </para>
<para>Некоторые функции возвращают <constant>null</constant>, если невозможно вернуть значение или произошла ошибка. Также <constant>null</constant> используется как пустой вектор или матрица, или пустая ссылка.</para>
      </sect2>

    </sect1>

    <sect1 id="genius-gel-variables">
      <title>Использование переменных</title>

      <para lang="en">
Syntax:
<programlisting lang="en">VariableName
</programlisting>
Example:
<screen lang="en"><prompt>genius&gt; </prompt><userinput>e</userinput>
= 2.71828182846
</screen>
      </para>

      <para>Чтобы вычислить значение переменной, просто введите имя переменной и программа вернёт её значение. Можно использовать переменную в любом месте, где обычно используется число или строка. Кроме того, переменные необходимы при определении функций, принимающих аргументы (см. <xref linkend="genius-gel-functions-defining"/>).</para>

      <tip>
        <title>Использование автозавершения по клавише Tab</title>
        <para>Вы можете использовать автозавершение по нажатию клавиши Tab, чтобы Genius автоматически подставлял полное имя переменной. Попробуйте набрать несколько первых букв имени и нажать <userinput>Tab</userinput>.</para>
      </tip>

      <important>
        <title>Имена переменных чувствительны к регистру</title>
        <para>Имена переменных чувствительны к регистру символов. Это означает, что переменные <varname>hello</varname>, <varname>HELLO</varname> и <varname>Hello</varname> — это разные переменные.</para>
      </important>


      <sect2 id="genius-gel-variables-setting">
        <title>Присваивание значения переменным</title>
        <para lang="en">
Syntax:
<programlisting lang="en"><![CDATA[<identifier> = <value>
<identifier> := <value>]]>
</programlisting>
Example:
<programlisting lang="en">x = 3
x := 3
</programlisting>
        </para>

        <para lang="en">
To assign a value to a variable, use the <literal>=</literal> or <literal>:=</literal> operators. These operators set the value of the variable and return the value you set, so you can do things like
<programlisting lang="en">a = b = 5
</programlisting>
This will set <varname>b</varname> to 5 and then also set <varname>a</varname> to 5.
        </para>

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

	<para lang="en">
	  For more information about the scope of variables, that is when are what variables visible, see <xref linkend="genius-gel-variables-global"/>.
	</para>
      </sect2>

      <sect2 id="genius-gel-variables-built-in">
        <title>Встроенные переменные</title>
        <para lang="en">
GEL has a number of built-in ‘variables’, such as
<varname>e</varname>, <varname>pi</varname> or <varname>GoldenRatio</varname>.  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 <xref linkend="genius-gel-function-list-constants"/> for a full list.  Note that <varname>i</varname> 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 <userinput>1i</userinput>.
        </para>
      </sect2>


      <sect2 id="genius-gel-previous-result">
        <title>Переменные с результатом предыдущего вычисления</title>
        <para lang="en">
The <varname>Ans</varname> and <varname>ans</varname> 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:
<programlisting lang="en">Ans+389
</programlisting>
        </para>
      </sect2>
    </sect1>

    <sect1 id="genius-gel-functions">
      <title>Использование функций</title>

      <para lang="en">
Syntax:
<programlisting lang="en">FunctionName(argument1, argument2, ...)
</programlisting>
Example:
<programlisting lang="en">Factorial(5)
cos(2*pi)
gcd(921,317)
</programlisting>

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.
      </para>

      <para lang="en">
	      There are many built-in functions, such as <link linkend="gel-function-sin"><function>sin</function></link>, <link linkend="gel-function-cos"><function>cos</function></link> and <link linkend="gel-function-tan"><function>tan</function></link>. You can use the <link linkend="gel-command-help"><function>help</function></link> built-in command to get a list of available functions, or see <xref linkend="genius-gel-function-list"/> for a full listing.
      </para>

      <tip>
        <title>Использование автозавершения по клавише Tab</title>
        <para>Можно использовать автозавершение по клавише Tab, чтобы Genius автоматически подставлял имена функций. Попробуйте набрать первые несколько букв имени и нажать <userinput>Tab</userinput>.</para>
      </tip>

      <important>
        <title>Имена функций чувствительны к регистру</title>
        <para>Имена функций чувствительны к регистру символов. Это означает, что функции <function>dosomething</function>, <function>DOSOMETHING</function> и <function>DoSomething</function> — это разные функции.</para>
      </important>


      <sect2 id="genius-gel-functions-defining">
        <title>Определение функций</title>
        <para lang="en">
Syntax:
<programlisting lang="en"><![CDATA[function <identifier>(<comma separated arguments>) = <function body>
<identifier> = (`() = <function body>)
]]></programlisting>
The <literal>`</literal> is the backquote character, and signifies an anonymous function. By setting it to a variable name you effectively define a function.
        </para>

        <para lang="en">
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:
<programlisting lang="en">function addup(a,b,c) = a+b+c
</programlisting>
then <userinput>addup(1,4,9)</userinput> yields 14
        </para>
      </sect2>

      <sect2 id="genius-gel-functions-variable-argument-lists">
        <title lang="en">Variable Argument Lists</title>
        <para lang="en">
If you include <literal>...</literal> 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 <constant>null</constant>. Otherwise, it will be a horizontal vector containing all the arguments. For example:
<programlisting lang="en">function f(a,b...) = b
</programlisting>
Then <userinput>f(1,2,3)</userinput> yields <computeroutput>[2,3]</computeroutput>, while <userinput>f(1)</userinput> yields a <constant>null</constant>.
        </para>
      </sect2>


      <sect2 id="genius-gel-functions-passing-functions">
        <title lang="en">Passing Functions to Functions</title>

        <para lang="en">
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.
        </para>

        <para lang="en">
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:
<programlisting lang="en">function f(a,b) = a(b)+1;
function b(x) = x*x;
f(b,2)
</programlisting>
        </para>
        <para lang="en">
To pass functions that are not defined,
you can use an anonymous function (see <xref linkend="genius-gel-functions-defining"/>).  That is, you want to pass a function without giving it a name.
Syntax:
<programlisting lang="en"><![CDATA[function(<comma separated arguments>) = <function body>
`(<comma separated arguments>) = <function body>
]]></programlisting>
Example:
<programlisting lang="en">function f(a,b) = a(b)+1;
f(`(x) = x*x,2)
</programlisting>
This will return 5.
        </para>
      </sect2>


    <sect2 id="genius-gel-functions-operations">
      <title>Операции с функциями</title>
      <para lang="en">
	      Some functions allow arithmetic operations, and some single argument functions such as <link linkend="gel-function-exp"><function>exp</function></link> or <link linkend="gel-function-ln"><function>ln</function></link>, to operate on the function. For example,
<programlisting lang="en">exp(sin*cos+4)
</programlisting>
will return a function that takes <varname>x</varname> and returns <userinput>exp(sin(x)*cos(x)+4)</userinput>.  It is functionally equivalent
to typing
<programlisting lang="en">`(x) = exp(sin(x)*cos(x)+4)
</programlisting>

This operation can be useful when quickly defining functions. For example to create a function called <varname>f</varname>
to perform the above operation, you can just type:
<programlisting lang="en">f = exp(sin*cos+4)
</programlisting>
It can also be used in plotting. For example, to plot sin squared you can enter:
<programlisting lang="en">LinePlot(sin^2)
</programlisting>
      </para>

      <warning>
        <para lang="en">
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. 
        </para>
      </warning>
    </sect2>


    </sect1>

    <sect1 id="genius-gel-separator">
      <title>Разделитель</title>
      <para lang="en">
	      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 <literal>;</literal> 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:
<programlisting lang="en">3 ; 5
</programlisting>
This expression will yield 5.
      </para>
      <para lang="en">
This will require some parenthesizing to make it unambiguous sometimes,
especially if the <literal>;</literal> is not the top most primitive. This slightly differs from
other programming languages where the <literal>;</literal> 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 <literal>;</literal> is found at the end of a parenthesis or a block,
genius will append a null to it as if you would have written
<userinput>;null</userinput>.
This is useful in case you do not want to return a value from a loop,
or if you handle the return differently.
      </para>
      <para lang="en">
	      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.
      </para>
    </sect1>

    <sect1 id="genius-gel-comments">
      <title lang="en">Comments</title>
      <para lang="en">
	      GEL is similar to other scripting languages in that <literal>#</literal> 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,
<programlisting lang="en"># 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;
</programlisting>
      </para>
    </sect1>

    <sect1 id="genius-gel-modular-evaluation">
      <title lang="en">Modular Evaluation</title>
      <para lang="en">
	      Genius implements modular arithmetic.
To use it you just add "mod &lt;integer&gt;" after
the expression.  Example:
<userinput>2^(5!) * 3^(6!) mod 5</userinput>
It could be possible to do modular arithmetic by computing with integers and then modding in the end with
the <literal>%</literal> operator, which simply gives the remainder, but
that may be time consuming if not impossible when working with larger numbers.
For example, <userinput>10^(10^10) % 6</userinput> will simply not work (the exponent
will be too large), while
<userinput>10^(10^10) mod 6</userinput> is instantaneous.  The first expression first tries to compute the integer
<userinput>10^(10^10)</userinput> and then find remainder after division by 6, while the second expression evaluates
everything modulo 6 to begin with.
      </para>
      <para lang="en">
	      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:
<programlisting lang="en">10^-1 mod 101
1/10 mod 101</programlisting>
Modular evaluation also works with matrices including taking inverses,
powers, and dividing.
Example:
<programlisting lang="en">A = [1,2;3,4]
B = A^-1 mod 5
A*B mod 5</programlisting>
This should yield the identity matrix as B will be the inverse of A mod 5.
      </para>
      <para lang="en">
Some functions such as
<link linkend="gel-function-sqrt"><function>sqrt</function></link> or
<link linkend="gel-function-log"><function>log</function></link>
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:
<programlisting lang="en">genius&gt; sqrt(4) mod 7
=
[2, 5]
genius&gt; 2*2 mod 7
= 4</programlisting>
	<function>sqrt</function> will actually return all the possible square
	roots.
      </para>
      <para lang="en">
	      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 <literal>%</literal> 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.
      </para>
    </sect1>

    <sect1 id="genius-gel-operator-list">
      <title>Список операторов GEL</title>

      <para lang="en">
	      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. 
      </para>

      <variablelist>
        <varlistentry>
         <term lang="en"><userinput>a;b</userinput></term>
         <listitem>
           <para>Разделитель, просто вычисляющий как <varname>a</varname>, так и <varname>b</varname>, но возвращающий только результат <varname>b</varname>.</para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term lang="en"><userinput>a=b</userinput></term>
         <listitem>
           <para lang="en">
	     The assignment operator.  This assigns <varname>b</varname> to
<varname>a</varname> (<varname>a</varname> must be a valid <link linkend="genius-gel-lvalues">lvalue</link>) (note however that this operator
may be translated to <literal>==</literal> if used in a place where boolean
expression is expected)
           </para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term lang="en"><userinput>a:=b</userinput></term>
         <listitem>
           <para lang="en">
	     The assignment operator.  Assigns <varname>b</varname> to
<varname>a</varname> (<varname>a</varname> must be a valid <link linkend="genius-gel-lvalues">lvalue</link>).  This is
different from <literal>=</literal> because it never gets translated to a
<literal>==</literal>.
           </para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term lang="en"><userinput>|a|</userinput></term>
         <listitem>
           <para lang="en">
		   Absolute value.
		   In case the expression is a complex number the result will be the modulus
(distance from the origin).  For example:
<userinput>|3 * e^(1i*pi)|</userinput>
returns 3.
	  </para>
          <para>Смотрите <ulink url="http://mathworld.wolfram.com/AbsoluteValue.html">Mathworld</ulink> для дополнительной информации.</para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term lang="en"><userinput>a^b</userinput></term>
         <listitem>
           <para>Возводит переменную <varname>a</varname> в степень <varname>b</varname>.</para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term lang="en"><userinput>a.^b</userinput></term>
         <listitem>
           <para>Поэлементное возведение в степень. Возводит каждый элемент матрицы <varname>a</varname> в степень <varname>b</varname>. Или, если <varname>b</varname> — матрица той же размерности, что и <varname>a</varname>, выполняет операцию поэлементно. Если <varname>a</varname> — число, а <varname>b</varname> — матрица, то создаёт матрицу той же размерности, что и <varname>b</varname> со значением <varname>a</varname>, возведённым во все степени, содержащиеся в <varname>b</varname>.</para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term lang="en"><userinput>a+b</userinput></term>
         <listitem>
           <para lang="en">
             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.
           </para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term lang="en"><userinput>a-b</userinput></term>
         <listitem>
           <para>Вычитание. Вычитает два числа, матрицы или функции.</para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term lang="en"><userinput>a*b</userinput></term>
         <listitem>
           <para>Умножение. Это обычное умножение матриц.</para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term lang="en"><userinput>a.*b</userinput></term>
         <listitem>
           <para>Поэлементное умножение, если <varname>a</varname> и <varname>b</varname> являются матрицами.</para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term lang="en"><userinput>a/b</userinput></term>
         <listitem>
           <para lang="en">
		   Division.  When <varname>a</varname> and <varname>b</varname> are just numbers
		   this is the normal division.  When they are matrices, then this is
		   equivalent to <userinput>a*b^-1</userinput>.
           </para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term lang="en"><userinput>a./b</userinput></term>
         <listitem>
           <para lang="en">
		   Element by element division.  Same as <userinput>a/b</userinput> for
		   numbers, but operates element by element on matrices.
           </para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term lang="en"><userinput>a\b</userinput></term>
         <listitem>
           <para>Обратное деление. Это то же самое, что <userinput>b/a</userinput>.</para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term lang="en"><userinput>a.\b</userinput></term>
         <listitem>
           <para>Поэлементное обратное деление.</para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term lang="en"><userinput>a%b</userinput></term>
         <listitem>
           <para lang="en">
	     The mod operator.  This does not turn on the <link linkend="genius-gel-modular-evaluation">modular mode</link>, but
             just returns the remainder of integer division
             <userinput>a/b</userinput>.
           </para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term lang="en"><userinput>a.%b</userinput></term>
         <listitem>
           <para lang="en">
             Element by element mod operator.  Returns the remainder
	     after element by element integer division
	     <userinput>a./b</userinput>.
           </para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term lang="en"><userinput>a mod b</userinput></term>
         <listitem>
           <para lang="en">
             Modular evaluation operator.  The expression <varname>a</varname>
	     is evaluated modulo <varname>b</varname>.  See <xref linkend="genius-gel-modular-evaluation"/>.
	     Some functions and operators behave differently modulo an integer.
           </para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term lang="en"><userinput>a!</userinput></term>
         <listitem>
           <para>Факториал: <userinput>1*...*(n-2)*(n-1)*n</userinput>.</para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term lang="en"><userinput>a!!</userinput></term>
         <listitem>
           <para>Двойной факториал: <userinput>1*...*(n-4)*(n-2)*n</userinput>.</para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term lang="en"><userinput>a==b</userinput></term>
         <listitem>
           <para lang="en">
	     Equality operator.
	     Returns <constant>true</constant> or <constant>false</constant>
	     depending on <varname>a</varname> and <varname>b</varname> being equal or not.
           </para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term lang="en"><userinput>a!=b</userinput></term>
         <listitem>
           <para>Оператор неравенства, возвращает <constant>true</constant>, если <varname>a</varname> не равно <varname>b</varname>, в противном случае возвращает <constant>false</constant>.</para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term lang="en"><userinput>a&lt;&gt;b</userinput></term>
         <listitem>
           <para>Альтернативный оператор неравенства, возвращает <constant>true</constant>, если <varname>a</varname> не равно <varname>b</varname>, иначе возвращает <constant>false</constant>.</para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term lang="en"><userinput>a&lt;=b</userinput></term>
         <listitem>
           <para lang="en">
             Less than or equal operator,
	     returns <constant>true</constant> if <varname>a</varname> is
	     less than or equal to 
	     <varname>b</varname> else returns <constant>false</constant>.
	     These can be chained as in <userinput>a &lt;= b &lt;= c</userinput> (can
	     also be combined with the less than operator).
           </para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term lang="en"><userinput>a&gt;=b</userinput></term>
         <listitem>
           <para lang="en">
             Greater than or equal operator,
	     returns <constant>true</constant> if <varname>a</varname> is
	     greater than or equal to 
	     <varname>b</varname> else returns <constant>false</constant>.
	     These can be chained as in <userinput>a &gt;= b &gt;= c</userinput>
	     (and they can also be combined with the greater than operator).
           </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><userinput>a&lt;b</userinput></term>
         <listitem>
           <para lang="en">
             Less than operator,
	     returns <constant>true</constant> if <varname>a</varname> is
	     less than 
	     <varname>b</varname> else returns <constant>false</constant>.
	     These can be chained as in <userinput>a &lt; b &lt; c</userinput>
	     (they can also be combined with the less than or equal to operator).
           </para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term lang="en"><userinput>a&gt;b</userinput></term>
         <listitem>
           <para lang="en">
             Greater than operator,
	     returns <constant>true</constant> if <varname>a</varname> is
	     greater than 
	     <varname>b</varname> else returns <constant>false</constant>.
	     These can be chained as in <userinput>a &gt; b &gt; c</userinput>
	     (they can also be combined with the greater than or equal to operator).
           </para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term lang="en"><userinput>a&lt;=&gt;b</userinput></term>
         <listitem>
           <para>Оператор сравнения. Если <varname>a</varname> равно <varname>b</varname>, возвращает 0; если <varname>a</varname> меньше <varname>b</varname>, возвращает -1; если <varname>a</varname> больше <varname>b</varname>, возвращает 1.</para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term lang="en"><userinput>a and b</userinput></term>
         <listitem>
           <para lang="en">
		   Logical and.  Returns true if both
		   <varname>a</varname> and <varname>b</varname> are true,
		   else returns false.  If given numbers, nonzero numbers
		   are treated as true.
           </para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term lang="en"><userinput>a or b</userinput></term>
         <listitem>
           <para lang="en">
             Logical or.
	     Returns true if either
	     <varname>a</varname> or <varname>b</varname> is true,
	     else returns false.  If given numbers, nonzero numbers
	     are treated as true.
           </para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term lang="en"><userinput>a xor b</userinput></term>
         <listitem>
           <para lang="en">
             Logical xor.
	     Returns true if exactly one of
	     <varname>a</varname> or <varname>b</varname> is true,
	     else returns false.  If given numbers, nonzero numbers
	     are treated as true.
           </para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term lang="en"><userinput>not a</userinput></term>
         <listitem>
           <para lang="en">
		   Logical not.  Returns the logical negation of <varname>a</varname>.
           </para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term lang="en"><userinput>-a</userinput></term>
         <listitem>
           <para lang="en">
             Negation operator.  Returns the negative of a number or a matrix (works element-wise on a matrix).
           </para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term lang="en"><userinput>&amp;a</userinput></term>
         <listitem>
           <para lang="en">
             Variable referencing (to pass a reference to a variable).
	     See <xref linkend="genius-gel-references"/>.
           </para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term lang="en"><userinput>*a</userinput></term>
         <listitem>
           <para lang="en">
             Variable dereferencing (to access a referenced variable).
	     See <xref linkend="genius-gel-references"/>.
           </para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term lang="en"><userinput>a'</userinput></term>
         <listitem>
           <para lang="en">
		   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 <varname>a</varname> is x+iy, then the j,i element of <userinput>a'</userinput> is x-iy.
           </para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term lang="en"><userinput>a.'</userinput></term>
         <listitem>
           <para lang="en">
             Matrix transpose, does not conjugate the entries.  That is, 
	     the i,j element of <varname>a</varname>  becomes the j,i element of <userinput>a.'</userinput>.
           </para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term lang="en"><userinput>a@(b,c)</userinput></term>
         <listitem>
           <para lang="en">
	     Get element of a matrix in row <varname>b</varname> and column
	     <varname>c</varname>.   If <varname>b</varname>,
	     <varname>c</varname> are vectors, then this gets the corresponding
	     rows, columns or submatrices.
           </para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term lang="en"><userinput>a@(b,)</userinput></term>
         <listitem>
           <para lang="en">
             Get row of a matrix (or multiple rows if <varname>b</varname> is a vector).
           </para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term lang="en"><userinput>a@(b,:)</userinput></term>
         <listitem>
           <para>То же, что и выше.</para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term lang="en"><userinput>a@(,c)</userinput></term>
         <listitem>
           <para>Возвращает столбец матрицы (или столбцы, если <varname>c</varname> является вектором).</para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term lang="en"><userinput>a@(:,c)</userinput></term>
         <listitem>
           <para>То же, что и выше.</para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term lang="en"><userinput>a@(b)</userinput></term>
         <listitem>
           <para lang="en">
             Get an element from a matrix treating it as a vector.  This will
	     traverse the matrix row-wise.
           </para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term lang="en"><userinput>a:b</userinput></term>
         <listitem>
           <para lang="en">
             Build a vector from <varname>a</varname> to <varname>b</varname> (or specify a row, column region for the <literal>@</literal> operator).  For example to get rows 2 to 4 of matrix <varname>A</varname> we could do
	     <programlisting lang="en">A@(2:4,)
	     </programlisting>
	     as <userinput>2:4</userinput> will return a vector
	     <userinput>[2,3,4]</userinput>.
           </para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term lang="en"><userinput>a:b:c</userinput></term>
         <listitem>
           <para lang="en">
	     Build a vector from <varname>a</varname> to <varname>c</varname>
	     with <varname>b</varname> as a step.  That is for example
	     <programlisting lang="en">genius&gt; 1:2:9
=
`[1, 3, 5, 7, 9]
</programlisting>
           </para>
	   <para lang="en">
	     When the numbers involved are floating point numbers, for example
	     <userinput>1.0:0.4:3.0</userinput>, 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
	     <userinput>2^-20</userinput> 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 <function>float</function> if you wish to get floating
	     point numbers in the end.  For example
	     <userinput>1:2/5:3</userinput> does the right thing and
	     <userinput>float(1:2/5:3)</userinput> even gives you floating
	     point numbers and is ever so slightly more precise than
	     <userinput>1.0:0.4:3.0</userinput>.
           </para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term lang="en"><userinput>(a)i</userinput></term>
         <listitem>
           <para lang="en">
	     Make <varname>a</varname> into an imaginary number (multiply <varname>a</varname> by the
	     imaginary).  Normally the imaginary number <varname>i</varname> is
	     written as <userinput>1i</userinput>.  So the above is equal to
	     <programlisting lang="en">(a)*1i
	     </programlisting>
           </para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term lang="en"><userinput>`a</userinput></term>
         <listitem>
           <para lang="en">
             Quote an identifier so that it doesn't get evaluated.  Or
	     quote a matrix so that it doesn't get expanded.
           </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><userinput>a swapwith b</userinput></term>
         <listitem>
           <para>Меняет местами значение <varname>a</varname> со значением <varname>b</varname>. В настоящее время не работает с диапазонами элементов матрицы. Возвращает <constant>null</constant>. Доступен, начиная с версии 1.0.13.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><userinput>increment a</userinput></term>
         <listitem>
           <para>Инкремент переменной <varname>a</varname> на 1. Если <varname>a</varname> — матрица, то инкрементирует каждый элемент. Это эквивалентно   <userinput>a=a+1</userinput>, но немного быстрее. Возвращает <constant>null</constant>. Доступен с версии 1.0.13.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><userinput>increment a by b</userinput></term>
         <listitem>
           <para>Инкремент переменной <varname>a</varname> на величину <varname>b</varname>. Если <varname>a</varname> — матрица, то инкрементирует каждый элемент. Это эквивалентно <userinput>a=a+b</userinput>, но немного быстрее. Возвращает <constant>null</constant>. Доступен с версии 1.0.13.</para>
         </listitem>
        </varlistentry>


      </variablelist>

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

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

<note>
<para lang="en">
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 <userinput>-1^k</userinput> is really <userinput>(-1)^k</userinput>,
but <userinput>-foo(1)^k</userinput> is really <userinput>-(foo(1)^k)</userinput>.  So
be careful how you use it and if in doubt, add parentheses.
</para>
</note>
    </sect1>

  </chapter>

  <!-- ============= GEL Programming ========================== -->
  <chapter id="genius-gel-programming">
    <title>Программирование в GEL</title>

    <sect1 id="genius-gel-conditionals">
      <title>Условные операторы</title>
      <para lang="en">
Syntax:
<programlisting lang="en"><![CDATA[if <expression1> then <expression2> [else <expression3>]
]]></programlisting>
If <literal>else</literal> is omitted, then if the <literal>expression1</literal> yields <constant>false</constant> or 0, <literal>NULL</literal> is returned.
      </para>
      <para lang="en">
Examples:
<programlisting lang="en"><![CDATA[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 )
]]></programlisting>
Note that <literal>=</literal> will be translated to <literal>==</literal> if used inside the expression for <literal>if</literal>, so
<programlisting lang="en">if a=5 then a=a-1
</programlisting>
will be interpreted as:
<programlisting lang="en">if a==5 then a:=a-1
</programlisting>
      </para>
    </sect1>

    <sect1 id="genius-gel-loops">
      <title>Циклы</title>

      <sect2 id="genius-gel-loops-while">
        <title>Циклы While</title>
        <para lang="en">
Syntax:
<programlisting lang="en"><![CDATA[while <expression1> do <expression2>
until <expression1> do <expression2>
do <expression2> while <expression1>
do <expression2> until <expression1>]]></programlisting>

	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 <literal>NULL</literal> if no iteration was done.  In the boolean expression, <literal>=</literal> is translated into <literal>==</literal> just as for the <literal>if</literal> statement.
        </para>
      </sect2>

      <sect2 id="genius-gel-loops-for">
        <title>Циклы For</title>
        <para lang="en">
Syntax:
<programlisting lang="en"><![CDATA[for <identifier> = <from> to <to> do <body>
for <identifier> = <from> to <to> by <increment> do <body>]]></programlisting>

Loop with identifier being set to all values from <literal>&lt;from&gt;</literal> to <literal>&lt;to&gt;</literal>, 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 <literal>&lt;from&gt;</literal> if body was never evaluated. The variable is guaranteed to be initialized after a loop, so you can safely use it.  Also the <literal>&lt;from&gt;</literal>, <literal>&lt;to&gt;</literal> and <literal>&lt;increment&gt;</literal> must be non complex values. The <literal>&lt;to&gt;</literal> is not guaranteed to be hit, but will never be overshot, for example the following prints out odd numbers from 1 to 19:
<programlisting lang="en">for i = 1 to 20 by 2 do print(i)
</programlisting>
        </para>
        <para lang="en">
		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 
<programlisting lang="en">for x = 0 to 1 by 0.1 do print(x)
</programlisting>
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:
<programlisting lang="en">for x = 0 to 1 by 1/10 do print(x)
</programlisting>
		This check is done only from version 1.0.16 onwards, so execution of your code may differ on older versions.
	</para>
      </sect2>

      <sect2 id="genius-gel-loops-foreach">
        <title>Циклы Foreach</title>
        <para lang="en">
Syntax:
<programlisting lang="en"><![CDATA[for <identifier> in <matrix> do <body>]]></programlisting>

			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:
<programlisting lang="en">for n in [1,2:3,4] do print(n)
</programlisting>
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,
<programlisting lang="en">for n in RowsOf ([1,2:3,4]) do print(n)
</programlisting>
will print out [1,2] and then [3,4].
        </para>
      </sect2>

      <sect2 id="genius-gel-loops-break-continue">
        <title>Break и Continue</title>
        <para lang="en">
You can also use the <literal>break</literal> and <literal>continue</literal> commands in loops. The continue <literal>continue</literal> command will restart the current loop at its next iteration, while the <literal>break</literal> command exits the current loop.
<programlisting lang="en"><![CDATA[while(<expression1>) do (
  if(<expression2>) break
  else if(<expression3>) continue;
  <expression4>
)
]]></programlisting>
        </para>
      </sect2>
    </sect1>

    <sect1 id="genius-gel-sums-products">
      <title>Суммы и произведения</title>
      <para lang="en">
Syntax:
<programlisting lang="en"><![CDATA[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>]]></programlisting>

If you substitute <literal>for</literal> with <literal>sum</literal> or <literal>prod</literal>, then you will get a sum or a product instead of a <literal>for</literal> loop. Instead of returning the last value, these will return the sum or the product of the values respectively.
      </para>
      <para>Если тело цикла не вычислялось (например, <userinput>sum i=1 to 0 do ...</userinput>), то <literal>sum</literal> возвращает 0, а <literal>prod</literal> возвращает 1.</para>
      <para lang="en">
	      For floating point numbers the same roundoff error protection is done as in the for loop.
	     See <xref linkend="genius-gel-loops-for"/>.
      </para>
    </sect1>

    <sect1 id="genius-gel-comparison-operators">
      <title>Операторы сравнения</title>
      <para>В GEL поддерживаются следующие стандартные операторы сравнения, имеющие очевидное значение: <literal>==</literal>, <literal>&gt;=</literal>, <literal>&lt;=</literal>, <literal>!=</literal>, <literal>&lt;&gt;</literal>, <literal>&lt;</literal>, <literal>&gt;</literal>. Они возвращают <constant>true</constant> или <constant>false</constant>. Операторы <literal>!=</literal> и <literal>&lt;&gt;</literal> эквивалентны и означают «не равно». GEL также поддерживает оператор <literal>&lt;=&gt;</literal>, который возвращает -1, если левая сторона меньше, 0 при равенстве обеих сторон и 1, если левая сторона больше.</para>

      <para lang="en">
	Normally <literal>=</literal> is translated to <literal>==</literal> if
	it happens to be somewhere where GEL is expecting a condition such as
	in the if condition.  For example
	<programlisting lang="en">if a=b then c
if a==b then c
</programlisting>
	are the same thing in GEL.  However you should really use
	<literal>==</literal> or <literal>:=</literal> when you want to compare
	or assign respectively if you want your code to be easy to read and
	to avoid mistakes.
      </para>

      <para lang="en">
	All the comparison operators (except for the
	<literal>&lt;=&gt;</literal> operator, which
	behaves normally), are not strictly binary operators, they can in fact
	be grouped in the normal mathematical way, e.g.:
	(<literal>1&lt;x&lt;=y&lt;5</literal>) is
	a legal boolean expression and means just what it should, that is
	(1&lt;x and x≤y and y&lt;5)
      </para>
      <para lang="en">
	To build up logical expressions use the words <literal>not</literal>,
	<literal>and</literal>, <literal>or</literal>, <literal>xor</literal>.
	The operators <literal>or</literal> and <literal>and</literal> are
special beasts as they evaluate their arguments one by one, so the usual trick
for conditional evaluation works here as well. For example, <literal>1 or a=1</literal> will not set
<literal>a=1</literal> since the first argument was true.
      </para>
    </sect1>

      <sect1 id="genius-gel-variables-global">
        <title>Глобальные переменные и область видимости переменных</title>
	<para lang="en">
	  GEL is a
	  <ulink url="https://en.wikipedia.org/wiki/Scope_%28programming%29">
	  dynamically scoped language</ulink>.  We will explain what this
	  means below.  That is, normal variables and functions are dynamically
	  scoped.  The exception are 
	  <link linkend="genius-gel-parameters">parameter variables</link>,
	  which are always global.
	</para>
	<para lang="en">
	  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
	  <function>f</function> defines a variable <varname>a</varname>
	  and then calls function <function>g</function>.  Then
	  function <function>g</function> can reference
	  <varname>a</varname>.  But once <function>f</function> returns,
	  the variable <varname>a</varname> goes out of scope.
	  For example, the following code will print out 5.
	  The function <function>g</function> cannot be called on the
	  top level (outside <function>f</function> as <varname>a</varname>
	  will not be defined).
<programlisting lang="en">function f() = (a:=5; g());
function g() = print(a);
f();
</programlisting>
        </para>
        <para lang="en">
	  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:
<programlisting lang="en">function f() = (a:=5; g());
function g() = print(a);
a:=10;
f();
</programlisting>
	  This code will still print out 5.  But if you call
	  <function>g</function> outside of <function>f</function> then
	  you will get a printout of 10.  Note that
	  setting <varname>a</varname>
	  to 5 inside <function>f</function> does not change
	  the value of <varname>a</varname> at the top (global) level,
	  so if you now check the value of <varname>a</varname> it will
	  still be 10.
        </para>
	<para lang="en">
	  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.
	</para>
	<para lang="en">
	  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:
<screen lang="en"><prompt>genius&gt; </prompt><userinput>function f(x) = sin(x)^2</userinput>
= (`(x)=(sin(x)^2))
<prompt>genius&gt; </prompt><userinput>function f(x) = sin(x)^2</userinput>
= (`(x)=(sin(x)^2))
<prompt>genius&gt; </prompt><userinput>function g(x) = ((function sin(x)=x^10);f(x))</userinput>
= (`(x)=((sin:=(`(x)=(x^10)));f(x)))
<prompt>genius&gt; </prompt><userinput>g(10)</userinput>
= 1e20
</screen>
	</para>
	<para lang="en">
	  Functions and variables defined at the top level are
	  considered global.  They are visible from anywhere.  As we
	  said the following function <function>f</function>
	  will not change the value of <varname>a</varname> to 5.
<programlisting lang="en">a=6;
function f() = (a:=5);
f();
</programlisting>
	  Sometimes, however, it is necessary to set
a global variable from inside a function.  When this behavior is needed,
use the
<link linkend="gel-function-set"><function>set</function></link> function. Passing a string or a quoted identifier to
this function sets the variable globally (on the top level).
For example, to set
<varname>a</varname> to the value 3 you could call:
<programlisting lang="en">set(`a,3)
</programlisting>
or:
<programlisting lang="en">set("a",3)
</programlisting>
        </para>
        <para lang="en">
	  The <function>set</function> 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.
        </para>
	<para lang="en">
		See also the
		<link linkend="gel-function-SetElement"><function>SetElement</function></link> and
		<link linkend="gel-function-SetVElement"><function>SetVElement</function></link> functions.
	</para>
	<para lang="en">
	  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.
	</para>
	<para lang="en">
	  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
	  <link linkend="genius-gel-true-local-variables">True
	  Local Variables</link> and
	  <link linkend="genius-gel-returning-functions">Returning
	  Functions</link>.
	</para>
      </sect1>

      <sect1 id="genius-gel-parameters">
        <title lang="en">Parameter variables</title>
	<para lang="en">
	  As we said before, there exist special variables called parameters
	  that exist in all scopes.  To declare a parameter called
	  <varname>foo</varname> with the initial value 1, we write
<programlisting lang="en"><![CDATA[parameter foo = 1
]]></programlisting>
	  From then on, <varname>foo</varname> is a strictly global variable.
	  Setting <varname>foo</varname> inside any function will modify the
	  variable in all contexts, that is, functions do not have a private
	  copy of parameters.
        </para>
        <para lang="en">
	  When you undefine a parameter using the
	  <link linkend="gel-function-undefine">
	  <function>undefine</function></link> function, it stops being
	  a parameter.
        </para>
        <para lang="en">
	  Some parameters are built-in and modify the behavior of genius.
        </para>
      </sect1>

    <sect1 id="genius-gel-returning">
      <title lang="en">Returning</title>
	<para lang="en">
	  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 <literal>return</literal> keyword. <literal>return</literal> takes one argument, which is the value to be returned.
      </para>
      <para lang="en">
Example:
<programlisting lang="en"><![CDATA[function f(x) = (
  y=1;
  while true do (
    if x>50 then return y;
    y=y+1;
    x=x+1
  )
)
]]></programlisting>
      </para>
    </sect1>


    <sect1 id="genius-gel-references">
      <title lang="en">References</title>
      <para lang="en">
	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.
      </para>
      <para lang="en">
	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
	<varname>A</varname> with initial eigenvector guess
	<varname>x</varname>, and store the computed eigenvector
	into the variable named <varname>v</varname>:
<programlisting lang="en"><![CDATA[RayleighQuotientIteration (A,x,0.001,100,&v)
]]></programlisting>
      </para>
      <para lang="en">
The details of how references work and the syntax is similar to the C language.
The operator
<literal>&amp;</literal> references a variable
and <literal>*</literal> dereferences a variable. Both can only be applied to an identifier,
so <literal>**a</literal> is not a legal expression in GEL.
      </para>
      <para lang="en">
References are best explained by an example:
<programlisting lang="en"><![CDATA[a=1;
b=&a;
*b=2;
]]></programlisting>
now <varname>a</varname> contains 2.  You can also reference functions:
<programlisting lang="en"><![CDATA[function f(x) = x+1;
t=&f;
*t(3)
]]></programlisting>
gives us 4.
      </para>
    </sect1>

    <sect1 id="genius-gel-lvalues">
      <title lang="en">Lvalues</title>
      <para lang="en">
	An lvalue is the left hand side of an assignment. In other words, an
	lvalue is what you assign something to.  Valid lvalues are:
<variablelist>
  <varlistentry>
    <term lang="en"><userinput>a</userinput></term>
    <listitem>
      <para lang="en">
	Identifier.  Here we would be setting the variable of name
	<varname>a</varname>.
      </para>
    </listitem>
  </varlistentry>
  <varlistentry>
    <term lang="en"><userinput>*a</userinput></term>
    <listitem>
      <para lang="en">
	Dereference of an identifier.  This will set whatever variable
	<varname>a</varname> points to.
      </para>
    </listitem>
  </varlistentry>
  <varlistentry>
    <term lang="en"><userinput>a@(&lt;region&gt;)</userinput></term>
    <listitem>
      <para lang="en">
	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.
      </para>
    </listitem>
  </varlistentry>
</variablelist>
      </para>
      <para lang="en">
Examples:
<programlisting lang="en">a:=4
*tmp := 89
a@(1,1) := 5
a@(4:8,3) := [1,2,3,4,5]'
</programlisting>
Note that both <literal>:=</literal> and <literal>=</literal> can be used
interchangeably.  Except if the assignment appears in a condition.
It is thus always safer to just use
<literal>:=</literal> when you mean assignment, and <literal>==</literal>
when you mean comparison.
      </para>
    </sect1>

  </chapter>

  <chapter id="genius-gel-programming-advanced">
    <title lang="en">Advanced Programming with GEL</title>

    <sect1 id="genius-gel-error-handling">
      <title>Обработка ошибок</title>
      <para lang="en">
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 <literal>bailout</literal>. If something went
really wrong and you want to completely kill the current computation, you can
use <literal>exception</literal>.
      </para>
      <para lang="en">
	For example if you want to check for arguments in your function.  You
could use the following code.
<programlisting lang="en">function f(M) = (
  if not IsMatrix (M) then (
    error ("M not a matrix!");
    bailout
  );
  ...
)
</programlisting>
      </para>
    </sect1>

    <sect1 id="genius-gel-toplevel-syntax">
      <title lang="en">Toplevel Syntax</title>
      <para lang="en">
	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.
      </para>
      <para lang="en">
	For example,
	<programlisting lang="en">function f(x)=x^2
f(3)
</programlisting>
	will print first the result of setting a function (a representation of
	the function, in this case <computeroutput>(`(x)=(x^2))</computeroutput>)
	and then the expected 9.  To avoid this, enter a separator
	after the function definition.
	<programlisting lang="en">function f(x)=x^2;
f(3)
</programlisting>
	If you need to put a separator into your function then you have to surround with
	parenthesis.  For example:
<programlisting lang="en">function f(x)=(
  y=1;
  for j=1 to x do
    y = y+j;
  y^2
);
</programlisting>
      </para>
      <para lang="en">
	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.
<programlisting lang="en">if Something() then
  DoSomething()
else
  DoSomethingElse()
</programlisting>
      </para>
      <para lang="en">
	The problem is that after <application>Genius Mathematics Tool</application> 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, <application>Genius Mathematics Tool</application> will
	go on to the next
	line, it will see <literal>else</literal>, and it will produce
	a parsing error.  To fix this, use parentheses.  <application>Genius Mathematics Tool</application> will not
	be satisfied until it has found that all parentheses are closed.
<programlisting lang="en">if Something() then (
  DoSomething()
) else (
  DoSomethingElse()
)
</programlisting>
      </para>
    </sect1>

     <sect1 id="genius-gel-returning-functions">
       <title lang="en">Returning Functions</title>
	<para lang="en">
	  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.
<programlisting lang="en">function f() = (
  k = 5;
  `(x) = (x+k)
)
</programlisting>
	  Notice that the function adds <varname>k</varname> to
	  <varname>x</varname>.  You could use this as follows.
<programlisting lang="en">g = f();
g(5)
</programlisting>
	  And <userinput>g(5)</userinput> should return 10.
        </para>
	<para lang="en">
	  One thing to note is that the value of <varname>k</varname>
	  that is used is the one that's in effect when the
	  <function>f</function> returns.  For example:
<programlisting lang="en">function f() = (
  k := 5;
  function r(x) = (x+k);
  k := 10;
  r
)
</programlisting>
	  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
	  <function>f</function> returns.  This is consistent with how you
	  would expect the function <function>r</function> to work inside
	  the function <function>f</function> 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 <function>f</function>,
	  and at the top level you define <varname>k</varname> to be
	  say 5.  Then when you run <function>f</function>, the function
	  <function>r</function> will not put <varname>k</varname> into
	  the private dictionary because it was global (toplevel)
	  at the time of definition of <function>r</function>.
	</para>
	<para lang="en">
	  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
<programlisting lang="en">function f() = (
  k := 5;
  function r(x) [k] = (x+k);
  k := 10;
  r
)
</programlisting>
	  will return a function that when called will add 5 to its
	  argument.  The local copy of <varname>k</varname> was created
	  when the function was defined.
	</para>
	<para lang="en">
	  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 <function>f</function> to see
	  the value of <varname>k</varname> from the toplevel despite
	  there being a local variable of the same name during definition.
	  So the code
<programlisting lang="en">function f() = (
  k := 5;
  function r(x) [] = (x+k);
  r
);
k := 10;
g = f();
g(10)
</programlisting>
	  will return 20 and not 15, which would happen if
	  <varname>k</varname> with a value of 5 was added to the private
	  dictionary.
	</para>
    </sect1>

    <sect1 id="genius-gel-true-local-variables">
      <title lang="en">True Local Variables</title>
      <para lang="en">
	When passing functions into other functions, the normal scoping of
	variables might be undesired.  For example:
<programlisting lang="en">k := 10;
function r(x) = (x+k);
function f(g,x) = (
  k := 5;
  g(x)
);
f(r,1)
</programlisting>
	you probably want the function <function>r</function>
	when passed as <function>g</function> into <function>f</function>
	to see <varname>k</varname> as 10 rather than 5, so that
	the code returns 11 and not 6.  However, as written, the function
	when executed will see the <varname>k</varname> that is
	equal to 5.  There are two ways to solve this.  One would be
	to have <function>r</function> get <varname>k</varname> in a
	private dictionary using the square bracket notation section
	<link linkend="genius-gel-returning-functions">Returning
	Functions</link>.
      </para>
      <para lang="en">
	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 <varname>k</varname> as a local variable in the
	function <function>f</function>.  To do this add a
	<command>local</command> 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,
<programlisting lang="en">function f(g,x) = (
  local g,x,k;
  k := 5;
  g(x)
);
</programlisting>
	Then the code will work as expected and prints out 11.
	Note that the <command>local</command> statement initializes
	all the referenced variables (except for function arguments) to
	a <constant>null</constant>.
      </para>
      <para lang="en">
	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 <function>f</function>
	will also work:
<programlisting lang="en">function f(g,x) = (
  local *;
  k := 5;
  g(x)
);
</programlisting>
      </para>
      <para lang="en">
	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.
      </para>
    </sect1>

    <sect1 id="genius-gel-startup-procedure">
      <title lang="en">GEL Startup Procedure</title>
      <para lang="en">
First the program looks for the installed library file (the compiled version <filename>lib.cgel</filename>) in the installed directory, then it looks into the current directory, and then it tries to load an uncompiled file called
<filename>~/.geniusinit</filename>.
      </para>
      <para lang="en">
If you ever change the library in its installed place, you’ll have to
first compile it with <command>genius --compile loader.gel &gt; lib.cgel</command>
      </para>
    </sect1>

    <sect1 id="genius-gel-loading-programs">
      <title>Загрузка программ</title>
      <para lang="en">
Sometimes you have a larger program you wrote into a file and want to read that file into <application>Genius Mathematics Tool</application>. In these situations, you have two options. You can keep the functions you use most inside the <filename>~/.geniusinit</filename> file. Or if you want to load up a file in a middle of a session (or from within another file), you can type <command>load &lt;list of filenames&gt;</command> 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:
<programlisting lang="en">load program1.gel program2.gel
load "Weird File Name With SPACES.gel"
</programlisting>
There are also <command>cd</command>, <command>pwd</command> and <command>ls</command> commands built in. <command>cd</command> will take one argument, <command>ls</command> will take an argument that is like the glob in the UNIX shell (i.e., you can use wildcards). <command>pwd</command> takes no arguments. For example:
<programlisting lang="en">cd directory_with_gel_programs
ls *.gel
</programlisting>
      </para>
    </sect1>

  </chapter>

  <!-- ============= Matrices ================================= -->
  <chapter id="genius-gel-matrices">
    <title>Матрицы в GEL</title>

    <para lang="en">
      Genius has support for vectors and matrices and possesses a sizable library of
      matrix manipulation and linear algebra functions.
    </para>

    <sect1 id="genius-gel-matrix-support">
      <title>Ввод матриц</title>
      <para lang="en">
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
<programlisting lang="en">[1,2,3;4,5,6;7,8,9]
</programlisting>
or
<programlisting lang="en">[1, 2, 3
 4, 5, 6
 7, 8, 9]
</programlisting>
Do not use both ';' and return at once on the same line though.
      </para>

      <para lang="en">
You can also use the matrix expansion functionality to enter matrices.
For example you can do:
<programlisting lang="en">a = [ 1, 2, 3
      4, 5, 6
      7, 8, 9]
b = [ a,  10
      11, 12]
</programlisting>
and you should get
<programlisting lang="en">[1,   2,  3, 10
 4,   5,  6, 10
 7,   8,  9, 10
 11, 11, 11, 12]
</programlisting>
similarly you can build matrices out of vectors and other stuff like that.
      </para>

      <para lang="en">
Another thing is that non-specified spots are initialized to 0, so
<programlisting lang="en">[1, 2, 3
 4, 5
 6]
</programlisting>
will end up being
<programlisting lang="en">
[1, 2, 3
 4, 5, 0
 6, 0, 0]
</programlisting>
      </para>

      <para lang="en">
	When matrices are evaluated, they are evaluated and traversed row-wise.  This is just
	like the <literal>M@(j)</literal> operator, which traverses the matrix row-wise.
      </para>

      <note>
        <para lang="en">
Be careful about using returns for expressions inside the
<literal>[ ]</literal> brackets, as they have a slightly different meaning
there.  You will start a new row.
        </para>
      </note>

    </sect1>

    <sect1 id="genius-gel-matrix-transpose">
      <title lang="en">Conjugate Transpose and Transpose Operator</title>
      <para lang="en">
You can conjugate transpose a matrix by using the <literal>'</literal> operator.  That is
the entry in the
<varname>i</varname>th column and the <varname>j</varname>th row will be
the complex conjugate of the entry in the
<varname>j</varname>th column and the <varname>i</varname>th row of the original matrix.
 For example:
<programlisting lang="en">[1,2,3]*[4,5,6]'
</programlisting>
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 <literal>.'</literal> operator.  For example:
<programlisting lang="en">[1,2,3]*[4,5,6i].'
</programlisting>
      </para>
	<para lang="en">
	  Note that normal transpose, that is the <literal>.'</literal> 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 <literal>.'</literal> operator when working with real
	  matrices and vectors.
	</para>
    </sect1>

    <sect1 id="genius-gel-matrix-linalg">
      <title>Линейная алгебра</title>
      <para lang="en">
	Genius implements many useful linear algebra and matrix manipulation
routines.  See the <link linkend="genius-gel-function-list-linear-algebra">Linear Algebra</link> and
<link linkend="genius-gel-function-list-matrix">Matrix Manipulation</link>
sections of the GEL function listing.
      </para>
      <para lang="en">
	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.
      </para>
      <para lang="en">
	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.
      </para>
      <para lang="en">
	In general when Genius computes the basis of a certain vectorspace
	(for example with the <link linkend="gel-function-NullSpace"><function>NullSpace</function></link>) 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.
      </para>
      <para lang="en">
	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 <link linkend="gel-function-rref"><function>rref</function></link> will be very fast.
      </para>
    </sect1>

  </chapter>

  <!-- ============= Polynomials ============================== -->
  <chapter id="genius-gel-polynomials">
    <title>Многочлены в GEL</title>

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

    <sect1 id="genius-gel-polynomials-using">
      <title>Использование многочленов</title>
      <para lang="en">
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,
<programlisting lang="en">[1,2,3]
</programlisting>
translates to a polynomial of
<programlisting lang="en">1 + 2*x + 3*x^2
</programlisting>
      </para>
      <para lang="en">
You can add, subtract and multiply polynomials using the
<link linkend="gel-function-AddPoly"><function>AddPoly</function></link>,
<link linkend="gel-function-SubtractPoly"><function>SubtractPoly</function></link>, and
<link linkend="gel-function-MultiplyPoly"><function>MultiplyPoly</function></link> functions respectively.
You can print a polynomial using the
<link linkend="gel-function-PolyToString"><function>PolyToString</function></link>
function.
For example,
<programlisting lang="en">PolyToString([1,2,3],"y")
</programlisting>
gives
<programlisting lang="en">3*y^2 + 2*y + 1
</programlisting>
You can also get a function representation of the polynomial so that you can
evaluate it. This is done by using
<link linkend="gel-function-PolyToFunction"><function>PolyToFunction</function></link>,
which
returns an anonymous function.
<programlisting lang="en">f = PolyToFunction([0,1,1])
f(2)
</programlisting>
      </para>
      <para lang="en">
	It is also possible to find roots of polynomials of degrees 1 through 4 by using the
function
<link linkend="gel-function-PolynomialRoots"><function>PolynomialRoots</function></link>,
which calls the appropriate formula function.  Higher degree polynomials must be converted to
functions and solved
numerically using a function such as
<link linkend="gel-function-FindRootBisection"><function>FindRootBisection</function></link>,
<link linkend="gel-function-FindRootFalsePosition"><function>FindRootFalsePosition</function></link>,
<link linkend="gel-function-FindRootMullersMethod"><function>FindRootMullersMethod</function></link>, or
<link linkend="gel-function-FindRootSecant"><function>FindRootSecant</function></link>.
      </para>
      <para lang="en">
See <xref linkend="genius-gel-function-list-polynomials"/> in the function list
for the rest of functions acting on polynomials.
      </para>
    </sect1>

  </chapter>

  <!-- ============= Set Theory ============================== -->
  <chapter id="genius-gel-settheory">
    <title>Теория множеств в GEL</title>

    <para lang="en">
      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.
    </para>

    <sect1 id="genius-gel-sets-using">
      <title lang="en">Using Sets</title>
      <para lang="en">
	Just like vectors, objects
      in sets can include numbers, strings, <constant>null</constant>, 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 <constant>0</constant> and <constant>0.0</constant>
      as two distinct elements.  The <constant>null</constant> is treated as an empty set.
    </para>
      <para lang="en">
	To build a set out of a vector, use the 
	<link linkend="gel-function-MakeSet"><function>MakeSet</function></link> function.
	Currently, it will just return a new vector where every element is unique.
<screen lang="en"><prompt>genius&gt; </prompt><userinput>MakeSet([1,2,2,3])</userinput>
= [1, 2, 3]
</screen>
</para>

	<para lang="en">
	Similarly there are functions 
	<link linkend="gel-function-Union"><function>Union</function></link>,
	<link linkend="gel-function-Intersection"><function>Intersection</function></link>,
	<link linkend="gel-function-SetMinus"><function>SetMinus</function></link>, which
	are rather self explanatory.  For example:
<screen lang="en"><prompt>genius&gt; </prompt><userinput>Union([1,2,3], [1,2,4])</userinput>
= [1, 2, 4, 3]
</screen>
	Note that no order is guaranteed for the return values.  If you wish to sort the vector you
should use the
	<link linkend="gel-function-SortVector"><function>SortVector</function></link> function.
	</para>

	<para lang="en">
	  For testing membership, there are functions
	<link linkend="gel-function-IsIn"><function>IsIn</function></link> and
	<link linkend="gel-function-IsSubset"><function>IsSubset</function></link>,
	which return a boolean value.  For example:
<screen lang="en"><prompt>genius&gt; </prompt><userinput>IsIn (1, [0,1,2])</userinput>
= true
</screen>
	The input <userinput>IsIn(x,X)</userinput> is equivalent to
	<userinput>IsSubset([x],X)</userinput>.  Note that since the empty set is a subset
	of every set, <userinput>IsSubset(null,X)</userinput> is always true.
	</para>

    </sect1>

  </chapter>

  <!-- ============= GEL function list ======================== -->
  <chapter id="genius-gel-function-list">
    <title>Список функций GEL</title>

    <!--&gel-function-list;-->

    <para lang="en">
To get help on a specific function from the console type:
<programlisting lang="en">help FunctionName
</programlisting>
    </para>

    <sect1 id="genius-gel-function-list-commands">
      <title>Команды</title>
      <variablelist>
        <varlistentry>
         <term lang="en"><anchor id="gel-command-help"/>help</term>
         <listitem>
          <synopsis>help</synopsis>
          <synopsis>help ИмяФункции</synopsis>
          <para>Показывает справку (или справку по функции/команде).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-command-load"/>load</term>
         <listitem>
          <synopsis>load "file.gel"</synopsis>
          <para lang="en">Load a file into the interpreter.  The file will execute
as if it were typed onto the command line.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-command-cd"/>cd</term>
         <listitem>
          <synopsis>cd /каталог/имя</synopsis>
          <para>Меняет рабочий каталог на <filename>/каталог/имя</filename>.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-command-pwd"/>pwd</term>
         <listitem>
          <synopsis>pwd</synopsis>
          <para>Выводит текущий рабочий каталог.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-command-ls"/>ls</term>
         <listitem>
          <synopsis>ls</synopsis>
          <para>Показывает список файлов в текущем каталоге.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-command-plugin"/>plugin</term>
         <listitem>
          <synopsis lang="en">plugin plugin_name</synopsis>
          <para lang="en">Load a plugin.  Plugin of that name must be installed on the system
in the proper directory.</para>
         </listitem>
        </varlistentry>
      </variablelist>
    </sect1>

    <sect1 id="genius-gel-function-list-basic">
      <title>Основные</title>
      <variablelist>
        <varlistentry>
         <term lang="en"><anchor id="gel-function-AskButtons"/>AskButtons</term>
         <listitem>
          <synopsis>AskButtons (вопрос)</synopsis>
          <synopsis>AskButtons (вопрос, кнопка1, ...)</synopsis>
	  <para>Задаёт вопрос и предлагает пользователю список кнопок (или меню вариантов в текстовом режиме). Возвращает отсчитываемый с 1 индекс нажатой кнопки. То есть 1, если нажата первая кнопка, 2 — если нажата вторая и т.д. Если пользователь закрыл окно (или просто нажал Enter в текстовом режиме), то возвращает <constant>null</constant>. Выполнение программы останавливается, пока пользователь не ответит.</para>
	  <para lang="en">Version 1.0.10 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-AskString"/>AskString</term>
         <listitem>
          <synopsis lang="en">AskString (query)</synopsis>
          <synopsis lang="en">AskString (query, default)</synopsis>
          <para lang="en">Asks a question and lets the user enter a string, which
it then returns.  If the user cancels or closes the window, then
<constant>null</constant> is returned.  The execution of the program
is blocked until the user responds.  If <varname>default</varname> is given, then it is pre-typed in for the user to just press enter on (version 1.0.6 onwards).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-Compose"/>Compose</term>
         <listitem>
          <synopsis lang="en">Compose (f,g)</synopsis>
          <para lang="en">Compose two functions and return a function that is the composition of <function>f</function> and <function>g</function>.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-ComposePower"/>ComposePower</term>
         <listitem>
          <synopsis lang="en">ComposePower (f,n,x)</synopsis>
          <para lang="en">Compose and execute a function with itself <varname>n</varname> times, passing <varname>x</varname> as argument.  Returning <varname>x</varname> if
<varname>n</varname> equals 0.
		Example:
          <screen lang="en"><prompt>genius&gt;</prompt> <userinput>function f(x) = x^2 ;</userinput>
<prompt>genius&gt;</prompt> <userinput>ComposePower (f,3,7)</userinput>
= 5764801
<prompt>genius&gt;</prompt> <userinput>f(f(f(7)))</userinput>
= 5764801
</screen>
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-Evaluate"/>Evaluate</term>
         <listitem>
          <synopsis lang="en">Evaluate (str)</synopsis>
          <para lang="en">Parses and evaluates a string.</para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term lang="en"><anchor id="gel-function-GetCurrentModulo"/>GetCurrentModulo</term>
         <listitem>
          <synopsis lang="en">GetCurrentModulo</synopsis>
          <para lang="en">Get current modulo from the context outside the function.  That is, if outside of
the function was executed in modulo (using <literal>mod</literal>) 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.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-Identity"/>Identity</term>
         <listitem>
          <synopsis lang="en">Identity (x)</synopsis>
	  <para lang="en">Identity function, returns its argument.  It is equivalent to <userinput>function Identity(x)=x</userinput>.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-IntegerFromBoolean"/>IntegerFromBoolean</term>
         <listitem>
          <synopsis>IntegerFromBoolean (bval)</synopsis>
	  <para>Преобразует логическое значение в целое число (0 для <constant>false</constant> или 1 для <constant>true</constant>). <varname>bval</varname> может также быть числом, в этом случае ненулевое значение интерпретируется как <constant>true</constant>, а нулевое — как <constant>false</constant>.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-IsBoolean"/>IsBoolean</term>
         <listitem>
          <synopsis>IsBoolean (arg)</synopsis>
          <para>Проверяет, является аргумент логическим значением (а не числом).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-IsDefined"/>IsDefined</term>
         <listitem>
          <synopsis lang="en">IsDefined (id)</synopsis>
          <para lang="en">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.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-IsFunction"/>IsFunction</term>
         <listitem>
          <synopsis>IsFunction (arg)</synopsis>
          <para>Проверяет, является ли аргумент функцией.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-IsFunctionOrIdentifier"/>IsFunctionOrIdentifier</term>
         <listitem>
          <synopsis lang="en">IsFunctionOrIdentifier (arg)</synopsis>
          <para lang="en">Check if argument is a function or an identifier.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-IsFunctionRef"/>IsFunctionRef</term>
         <listitem>
          <synopsis lang="en">IsFunctionRef (arg)</synopsis>
          <para lang="en">Check if argument is a function reference.  This includes variable
references.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-IsMatrix"/>IsMatrix</term>
         <listitem>
          <synopsis>IsMatrix (arg)</synopsis>
          <para>Проверяет, является ли аргумент матрицей. Хотя <constant>null</constant> иногда используют вместо пустой матрицы, функция <function>IsMatrix</function> не считает <constant>null</constant> матрицей.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-IsNull"/>IsNull</term>
         <listitem>
          <synopsis>IsNull (arg)</synopsis>
	  <para>Проверяет, имеет ли аргумент значение <constant>null</constant>.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-IsString"/>IsString</term>
         <listitem>
          <synopsis>IsString (arg)</synopsis>
          <para>Проверяет, является ли аргумент текстовой строкой.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-IsValue"/>IsValue</term>
         <listitem>
          <synopsis>IsValue (arg)</synopsis>
          <para>Проверяет, является ли аргумент числом.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-Parse"/>Parse</term>
         <listitem>
          <synopsis lang="en">Parse (str)</synopsis>
          <para lang="en">Parses but does not evaluate a string.  Note that certain
	    pre-computation is done during the parsing stage.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-SetFunctionFlags"/>SetFunctionFlags</term>
         <listitem>
          <synopsis lang="en">SetFunctionFlags (id,flags...)</synopsis>
          <para lang="en">Set flags for a function, currently <literal>"PropagateMod"</literal> and <literal>"NoModuloArguments"</literal>.
If <literal>"PropagateMod"</literal> 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 <literal>mod</literal>).  If
<literal>"NoModuloArguments"</literal>, then the arguments of the function are never evaluated using modular arithmetic.
 </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-SetHelp"/>SetHelp</term>
         <listitem>
          <synopsis lang="en">SetHelp (id,category,desc)</synopsis>
          <para lang="en">Set the category and help description line for a function.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-SetHelpAlias"/>SetHelpAlias</term>
         <listitem>
          <synopsis lang="en">SetHelpAlias (id,alias)</synopsis>
          <para lang="en">Sets up a help alias.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-chdir"/>chdir</term>
         <listitem>
          <synopsis>chdir (dir)</synopsis>
          <para>Изменяет текущий каталог. То же, что и <command>cd</command>.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-CurrentTime"/>CurrentTime</term>
         <listitem>
          <synopsis>CurrentTime</synopsis>
          <para>Возвращает текущее время UNIX с точностью до микросекунд в виде числа с плавающей точкой. То есть возвращает число секунд с 1 января 1970 г.</para>
	  <para lang="en">Version 1.0.15 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-display"/>display</term>
         <listitem>
          <synopsis lang="en">display (str,expr)</synopsis>
          <para lang="en">Display a string and an expression with a colon to separate them.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-DisplayVariables"/>DisplayVariables</term>
         <listitem>
          <synopsis lang="en">DisplayVariables (var1,var2,...)</synopsis>
	  <para lang="en">Display set of variables.  The variables can be given as
		  strings or identifiers.  For example:
	    <programlisting lang="en">DisplayVariables(`x,`y,`z)
	    </programlisting>
	  </para>
	  <para lang="en">
		  If called without arguments (must supply empty argument list) as
	    <programlisting lang="en">DisplayVariables()
	    </programlisting>
	    then all variables are printed including a stacktrace similar to
	    <guilabel>Show user variables</guilabel> in the graphical version.
	  </para>
	  <para lang="en">Version 1.0.18 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-error"/>error</term>
         <listitem>
          <synopsis>error (str)</synopsis>
          <para>Выводит строку в поток ошибок (на консоль).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-exit"/>exit</term>
         <listitem>
          <synopsis>exit</synopsis>
          <para>Псевдоним: <function>quit</function></para>
          <para>Завершает работу программы.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-false"/>false</term>
         <listitem>
          <synopsis>false</synopsis>
          <para lang="en">Aliases: <function>False</function> <function>FALSE</function></para>
	  <para>Логическое значение <constant>false</constant> (ложь).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-manual"/>manual</term>
         <listitem>
          <synopsis>manual</synopsis>
          <para>Показывает руководство пользователя.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-print"/>print</term>
         <listitem>
          <synopsis>print (str)</synopsis>
          <para>Выводит выражение и выполняет переход на новую строку. Аргумент <varname>str</varname> может быть любым выражением. Он преобразуется в строку перед выводом.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-printn"/>printn</term>
         <listitem>
          <synopsis>printn (str)</synopsis>
          <para>Выводит выражение без перехода на новую строку. Аргумент <varname>str</varname> может быть любым выражением. Он преобразуется в строку перед выводом.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-PrintTable"/>PrintTable</term>
         <listitem>
          <synopsis lang="en">PrintTable (f,v)</synopsis>
	  <para lang="en">Print a table of values for a function.  The values are in the 
		  vector <varname>v</varname>.  You can use the vector
		  building notation as follows:
      		  <programlisting lang="en">PrintTable (f,[0:10])
	    </programlisting>
	    If <varname>v</varname> is a positive integer, then the table of
	    integers from 1 up to and including v will be used.
	  </para>
	  <para lang="en">Version 1.0.18 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-protect"/>protect</term>
         <listitem>
          <synopsis lang="en">protect (id)</synopsis>
          <para lang="en">Protect a variable from being modified.  This is used on the internal GEL functions to
avoid them being accidentally overridden.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-ProtectAll"/>ProtectAll</term>
         <listitem>
          <synopsis lang="en">ProtectAll ()</synopsis>
          <para lang="en">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 <application>Genius Mathematics Tool</application> considers
unprotected variables as user defined.</para>
	  <para lang="en">Version 1.0.7 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-set"/>set</term>
         <listitem>
          <synopsis lang="en">set (id,val)</synopsis>
          <para lang="en">Set a global variable.  The <varname>id</varname>
            can be either a string or a quoted identifier.
	    For example:
	    <programlisting lang="en">set(`x,1)
	    </programlisting>
	    will set the global variable <varname>x</varname> to the value 1.
	  </para>
	  <para lang="en">The function returns the <varname>val</varname>, to be
	  usable in chaining.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-SetElement"/>SetElement</term>
         <listitem>
          <synopsis lang="en">SetElement (id,row,col,val)</synopsis>
	  <para lang="en">Set an element of a global variable which is a matrix.
		  The <varname>id</varname>
            can be either a string or a quoted identifier.
	    For example:
	    <programlisting lang="en">SetElement(`x,2,3,1)
	    </programlisting>
	    will set the second row third column element of the global variable <varname>x</varname> 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.
	  </para>
	  <para lang="en">The <varname>row</varname> and <varname>col</varname> can also be ranges, and the semantics are the same as for regular setting of the elements with an equals sign.
	  </para>
	  <para lang="en">The function returns the <varname>val</varname>, to be
	  usable in chaining.</para>
	  <para lang="en">Available from 1.0.18 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-SetVElement"/>SetVElement</term>
         <listitem>
          <synopsis lang="en">SetElement (id,elt,val)</synopsis>
	  <para lang="en">Set an element of a global variable which is a vector.
		  The <varname>id</varname>
            can be either a string or a quoted identifier.
	    For example:
	    <programlisting lang="en">SetElement(`x,2,1)
	    </programlisting>
	    will set the second element of the global vector variable <varname>x</varname> 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.
	  </para>
	  <para lang="en">The <varname>elt</varname> can also be a range, and the semantics are the same as for regular setting of the elements with an equals sign.
	  </para>
	  <para lang="en">The function returns the <varname>val</varname>, to be
	  usable in chaining.</para>
	  <para lang="en">Available from 1.0.18 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-string"/>string</term>
         <listitem>
          <synopsis>string (s)</synopsis>
          <para>Преобразует аргумент любого типа в строку.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-true"/>true</term>
         <listitem>
          <synopsis>true</synopsis>
          <para lang="en">Aliases: <function>True</function> <function>TRUE</function></para>
	  <para>Логическое значение <constant>true</constant> (истина).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-undefine"/>undefine</term>
         <listitem>
          <synopsis lang="en">undefine (id)</synopsis>
          <para lang="en">Alias: <function>Undefine</function></para>
          <para lang="en">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.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-UndefineAll"/>UndefineAll</term>
         <listitem>
          <synopsis lang="en">UndefineAll ()</synopsis>
	  <para lang="en">Undefine all unprotected global variables
	    (including functions and parameters).  Normally <application>Genius Mathematics Tool</application>
	    considers protected variables as system defined functions
	    and variables.  Note that <function>UndefineAll</function>
	    only removes the global definition of symbols not local ones,
	    so that it may be run from inside other functions safely.
	  </para>
	  <para lang="en">Version 1.0.7 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-unprotect"/>unprotect</term>
         <listitem>
          <synopsis lang="en">unprotect (id)</synopsis>
          <para lang="en">Unprotect a variable from being modified.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-UserVariables"/>UserVariables</term>
         <listitem>
          <synopsis>UserVariables ()</synopsis>
          <para>Возвращает вектор идентификаторов определённых пользователем (незащищённых) глобальных переменных.</para>
	  <para lang="en">Version 1.0.7 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-wait"/>wait</term>
         <listitem>
          <synopsis lang="en">wait (secs)</synopsis>
          <para lang="en">Waits a specified number of seconds.  <varname>secs</varname>
must be non-negative.  Zero is accepted and nothing happens in this case,
except possibly user interface events are processed.</para>
	  <para lang="en">Since version 1.0.18, <varname>secs</varname> can be a noninteger number, so
		  <userinput>wait(0.1)</userinput> will wait for one tenth of a second.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-version"/>version</term>
         <listitem>
          <synopsis lang="en">version</synopsis>
          <para lang="en">Returns the version of Genius as a horizontal 3-vector with
	  major version first, then minor version and finally the patch level.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-warranty"/>warranty</term>
         <listitem>
          <synopsis lang="en">warranty</synopsis>
          <para lang="en">Gives the warranty information.</para>
         </listitem>
        </varlistentry>
      </variablelist>

    </sect1>

    <sect1 id="genius-gel-function-parameters">
      <title>Параметры</title>
      <variablelist>
        <varlistentry>
         <term lang="en"><anchor id="gel-function-ChopTolerance"/>ChopTolerance</term>
         <listitem>
          <synopsis lang="en">ChopTolerance = number</synopsis>
          <para lang="en">Tolerance of the <function>Chop</function> function.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-ContinuousNumberOfTries"/>ContinuousNumberOfTries</term>
         <listitem>
          <synopsis lang="en">ContinuousNumberOfTries = number</synopsis>
          <para lang="en">How many iterations to try to find the limit for continuity and limits.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-ContinuousSFS"/>ContinuousSFS</term>
         <listitem>
          <synopsis lang="en">ContinuousSFS = number</synopsis>
          <para lang="en">How many successive steps to be within tolerance for calculation of continuity.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-ContinuousTolerance"/>ContinuousTolerance</term>
         <listitem>
          <synopsis lang="en">ContinuousTolerance = number</synopsis>
          <para lang="en">Tolerance for continuity of functions and for calculating the limit.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-DerivativeNumberOfTries"/>DerivativeNumberOfTries</term>
         <listitem>
          <synopsis lang="en">DerivativeNumberOfTries = number</synopsis>
          <para lang="en">How many iterations to try to find the limit for derivative.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-DerivativeSFS"/>DerivativeSFS</term>
         <listitem>
          <synopsis lang="en">DerivativeSFS = number</synopsis>
          <para lang="en">How many successive steps to be within tolerance for calculation of derivative.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-DerivativeTolerance"/>DerivativeTolerance</term>
         <listitem>
          <synopsis lang="en">DerivativeTolerance = number</synopsis>
          <para lang="en">Tolerance for calculating the derivatives of functions.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-ErrorFunctionTolerance"/>ErrorFunctionTolerance</term>
         <listitem>
          <synopsis lang="en">ErrorFunctionTolerance = number</synopsis>
	  <para lang="en">Tolerance of the <link linkend="gel-function-ErrorFunction"><function>ErrorFunction</function></link>.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-FloatPrecision"/>FloatPrecision</term>
         <listitem>
          <synopsis>FloatPrecision = число</synopsis>
          <para>Точность чисел с плавающей точкой.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-FullExpressions"/>FullExpressions</term>
         <listitem>
          <synopsis>FullExpressions = логическое значение</synopsis>
          <para>Выводить полные выражения, даже если они превышают длину строки.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-GaussDistributionTolerance"/>GaussDistributionTolerance</term>
         <listitem>
          <synopsis lang="en">GaussDistributionTolerance = number</synopsis>
	  <para lang="en">Tolerance of the <link linkend="gel-function-GaussDistribution"><function>GaussDistribution</function></link> function.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-IntegerOutputBase"/>IntegerOutputBase</term>
         <listitem>
          <synopsis lang="en">IntegerOutputBase = number</synopsis>
          <para lang="en">Integer output base.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-IsPrimeMillerRabinReps"/>IsPrimeMillerRabinReps</term>
         <listitem>
          <synopsis lang="en">IsPrimeMillerRabinReps = number</synopsis>
	  <para lang="en">Number of extra Miller-Rabin tests to run on a number before declaring it a prime in <link linkend="gel-function-IsPrime"><function>IsPrime</function></link>.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-LinePlotDrawLegends"/>LinePlotDrawLegends</term>
         <listitem>
          <synopsis lang="en">LinePlotDrawLegends = true</synopsis>
          <para lang="en">Tells genius to draw the legends for <link linkend="genius-gel-function-list-plotting">line plotting
	  functions</link> such as <link linkend="gel-function-LinePlot"><function>LinePlot</function></link>.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-LinePlotDrawAxisLabels"/>LinePlotDrawAxisLabels</term>
         <listitem>
          <synopsis lang="en">LinePlotDrawAxisLabels = true</synopsis>
          <para lang="en">Tells genius to draw the axis labels for <link linkend="genius-gel-function-list-plotting">line plotting
	  functions</link> such as <link linkend="gel-function-LinePlot"><function>LinePlot</function></link>.
          </para>
	  <para lang="en">Version 1.0.16 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-LinePlotVariableNames"/>LinePlotVariableNames</term>
         <listitem>
          <synopsis lang="en">LinePlotVariableNames = ["x","y","z","t"]</synopsis>
          <para lang="en">Tells genius which variable names are used as default names  for <link linkend="genius-gel-function-list-plotting">line plotting
	  functions</link> such as <link linkend="gel-function-LinePlot"><function>LinePlot</function></link> and friends.
          </para>
	  <para lang="en">Version 1.0.10 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-LinePlotWindow"/>LinePlotWindow</term>
         <listitem>
          <synopsis lang="en">LinePlotWindow = [x1,x2,y1,y2]</synopsis>
          <para lang="en">Sets the limits for <link linkend="genius-gel-function-list-plotting">line plotting
	  functions</link> such as <link linkend="gel-function-LinePlot"><function>LinePlot</function></link>.
          </para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term lang="en"><anchor id="gel-function-MaxDigits"/>MaxDigits</term>
         <listitem>
          <synopsis lang="en">MaxDigits = number</synopsis>
          <para lang="en">Maximum digits to display.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-MaxErrors"/>MaxErrors</term>
         <listitem>
          <synopsis lang="en">MaxErrors = number</synopsis>
          <para lang="en">Maximum errors to display.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-MixedFractions"/>MixedFractions</term>
         <listitem>
          <synopsis>MixedFractions = логическое значение</synopsis>
          <para>Если true, выводятся смешанные дроби.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-NumericalIntegralFunction"/>NumericalIntegralFunction</term>
         <listitem>
          <synopsis lang="en">NumericalIntegralFunction = function</synopsis>
	  <para lang="en">The function used for numerical integration in <link linkend="gel-function-NumericalIntegral"><function>NumericalIntegral</function></link>.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-NumericalIntegralSteps"/>NumericalIntegralSteps</term>
         <listitem>
          <synopsis lang="en">NumericalIntegralSteps = number</synopsis>
	  <para lang="en">Steps to perform in <link linkend="gel-function-NumericalIntegral"><function>NumericalIntegral</function></link>.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-OutputChopExponent"/>OutputChopExponent</term>
         <listitem>
          <synopsis lang="en">OutputChopExponent = number</synopsis>
	  <para lang="en">When another number in the object being printed (a matrix or a
value) is greater than
10<superscript>-OutputChopWhenExponent</superscript>, and
the number being printed is less than 
10<superscript>-OutputChopExponent</superscript>, then
display <computeroutput>0.0</computeroutput> instead of the number.
</para>
<para lang="en">
Output is never chopped if <function>OutputChopExponent</function> is zero.
It must be a non-negative integer.
</para>
<para lang="en">
If you want output always chopped according to
<function>OutputChopExponent</function>, then set
<function>OutputChopWhenExponent</function>, to something
greater than or equal to
<function>OutputChopExponent</function>.
</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-OutputChopWhenExponent"/>OutputChopWhenExponent</term>
         <listitem>
          <synopsis lang="en">OutputChopWhenExponent = number</synopsis>
	  <para lang="en">When to chop output.  See
          <link linkend="gel-function-OutputChopExponent"><function>OutputChopExponent</function></link>.
</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-OutputStyle"/>OutputStyle</term>
         <listitem>
          <synopsis>OutputStyle = строка</synopsis>
          <para>Стиль вывода, может быть <literal>normal</literal>, <literal>latex</literal>, <literal>mathml</literal> или <literal>troff</literal>.</para>
	  <para lang="en">
	    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:
	    <programlisting lang="en">OutputStyle = "latex"
</programlisting>
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-ResultsAsFloats"/>ResultsAsFloats</term>
         <listitem>
          <synopsis lang="en">ResultsAsFloats = boolean</synopsis>
          <para lang="en">Convert all results to floats before printing.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-ScientificNotation"/>ScientificNotation</term>
         <listitem>
          <synopsis lang="en">ScientificNotation = boolean</synopsis>
          <para lang="en">Use scientific notation.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-SlopefieldTicks"/>SlopefieldTicks</term>
         <listitem>
          <synopsis lang="en">SlopefieldTicks = [vertical,horizontal]</synopsis>
          <para lang="en">Sets the number of vertical and horizontal ticks in a
slopefield plot.  (See <link linkend="gel-function-SlopefieldPlot"><function>SlopefieldPlot</function></link>).
          </para>
	  <para lang="en">Version 1.0.10 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-SumProductNumberOfTries"/>SumProductNumberOfTries</term>
         <listitem>
          <synopsis lang="en">SumProductNumberOfTries = number</synopsis>
	  <para lang="en">How many iterations to try for <link linkend="gel-function-InfiniteSum"><function>InfiniteSum</function></link> and <link linkend="gel-function-InfiniteProduct"><function>InfiniteProduct</function></link>.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-SumProductSFS"/>SumProductSFS</term>
         <listitem>
          <synopsis lang="en">SumProductSFS = number</synopsis>
          <para lang="en">How many successive steps to be within tolerance for <link linkend="gel-function-InfiniteSum"><function>InfiniteSum</function></link> and <link linkend="gel-function-InfiniteProduct"><function>InfiniteProduct</function></link>.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-SumProductTolerance"/>SumProductTolerance</term>
         <listitem>
          <synopsis lang="en">SumProductTolerance = number</synopsis>
          <para lang="en">Tolerance for <link linkend="gel-function-InfiniteSum"><function>InfiniteSum</function></link> and <link linkend="gel-function-InfiniteProduct"><function>InfiniteProduct</function></link>.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-SurfacePlotDrawLegends"/>SurfacePlotDrawLegends</term>
         <listitem>
          <synopsis lang="en">SurfacePlotDrawLegends = true</synopsis>
          <para lang="en">Tells genius to draw the legends for <link linkend="genius-gel-function-list-plotting">surface plotting
	  functions</link> such as <link linkend="gel-function-SurfacePlot"><function>SurfacePlot</function></link>.
          </para>
	  <para lang="en">Version 1.0.16 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-SurfacePlotVariableNames"/>SurfacePlotVariableNames</term>
         <listitem>
          <synopsis lang="en">SurfacePlotVariableNames = ["x","y","z"]</synopsis>
          <para lang="en">Tells genius which variable names are used as default names for <link linkend="genius-gel-function-list-plotting">surface plotting
	  functions</link> using <link linkend="gel-function-SurfacePlot"><function>SurfacePlot</function></link>.
          Note that the <varname>z</varname> does not refer to the dependent (vertical) axis, but to the independent complex variable
          <userinput>z=x+iy</userinput>.
          </para>
	  <para lang="en">Version 1.0.10 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-SurfacePlotWindow"/>SurfacePlotWindow</term>
         <listitem>
          <synopsis lang="en">SurfacePlotWindow = [x1,x2,y1,y2,z1,z2]</synopsis>
          <para lang="en">Sets the limits for surface plotting (See <link linkend="gel-function-SurfacePlot"><function>SurfacePlot</function></link>).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-VectorfieldNormalized"/>VectorfieldNormalized</term>
         <listitem>
          <synopsis lang="en">VectorfieldNormalized = true</synopsis>
          <para lang="en">Should the vectorfield plotting have normalized arrow length.  If true, vector fields will only show direction
	   and not magnitude.  (See <link linkend="gel-function-VectorfieldPlot"><function>VectorfieldPlot</function></link>).
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-VectorfieldTicks"/>VectorfieldTicks</term>
         <listitem>
          <synopsis lang="en">VectorfieldTicks = [vertical,horizontal]</synopsis>
          <para lang="en">Sets the number of vertical and horizontal ticks in a
vectorfield plot.  (See <link linkend="gel-function-VectorfieldPlot"><function>VectorfieldPlot</function></link>).
          </para>
	  <para lang="en">Version 1.0.10 onwards.</para>
         </listitem>
        </varlistentry>

      </variablelist>
    </sect1>

    <sect1 id="genius-gel-function-list-constants">
      <title>Константы</title>
      <variablelist>
        <varlistentry>
         <term lang="en"><anchor id="gel-function-CatalanConstant"/>CatalanConstant</term>
         <listitem>
          <synopsis lang="en">CatalanConstant</synopsis>
          <para lang="en">
	    Catalan's Constant, approximately 0.915...  It is defined to be the series where terms are <userinput>(-1^k)/((2*k+1)^2)</userinput>, where <varname>k</varname> ranges from 0 to infinity.
	  </para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Catalan%27s_constant">Wikipedia</ulink> or
	    <ulink url="http://mathworld.wolfram.com/CatalansConstant.html">Mathworld</ulink> for more information.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-EulerConstant"/>EulerConstant</term>
         <listitem>
          <synopsis lang="en">EulerConstant</synopsis>
          <para lang="en">Aliases: <function>gamma</function></para>
          <para lang="en">
	    Euler's constant gamma.  Sometimes called the
	    Euler-Mascheroni constant.
	  </para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Euler-Mascheroni_constant">Wikipedia</ulink> or
	    <ulink url="http://planetmath.org/MascheroniConstant">Planetmath</ulink> or
	    <ulink url="http://mathworld.wolfram.com/Euler-MascheroniConstant.html">Mathworld</ulink> for more information.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-GoldenRatio"/>GoldenRatio</term>
         <listitem>
          <synopsis lang="en">GoldenRatio</synopsis>
          <para lang="en">The Golden Ratio.</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Golden_ratio">Wikipedia</ulink> or
	    <ulink url="http://planetmath.org/GoldenRatio">Planetmath</ulink> or
	    <ulink url="http://mathworld.wolfram.com/GoldenRatio.html">Mathworld</ulink> for more information.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-Gravity"/>Gravity</term>
         <listitem>
          <synopsis>Gravity</synopsis>
	  <para lang="en">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.</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Standard_gravity">Wikipedia</ulink> for more information.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-e"/>e</term>
         <listitem>
          <synopsis>e</synopsis>
          <para lang="en">
	    The base of the natural logarithm.  <userinput>e^x</userinput>
	    is the exponential function
	    <link linkend="gel-function-exp"><function>exp</function></link>.  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: <link linkend="gel-function-EulerConstant"><function>EulerConstant</function></link>.
	  </para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/E_(mathematical_constant)">Wikipedia</ulink> or
	    <ulink url="http://planetmath.org/E">Planetmath</ulink> or
	    <ulink url="http://mathworld.wolfram.com/e.html">Mathworld</ulink> for more information.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-pi"/>pi</term>
         <listitem>
          <synopsis>pi</synopsis>
          <para>Число «пи» — отношение длины окружности к её диаметру. Значение приблизительно равно 3.14159265359...</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Pi">Wikipedia</ulink> or
	    <ulink url="http://planetmath.org/Pi">Planetmath</ulink> or
	    <ulink url="http://mathworld.wolfram.com/Pi.html">Mathworld</ulink> for more information.
	  </para>
         </listitem>
        </varlistentry>

      </variablelist>
    </sect1>

    <sect1 id="genius-gel-function-list-numeric">
      <title>Числовые</title>
      <variablelist>
        <varlistentry>
         <term lang="en"><anchor id="gel-function-AbsoluteValue"/>AbsoluteValue</term>
         <listitem>
          <synopsis>AbsoluteValue (x)</synopsis>
          <para>Синонимы: <function>abs</function></para>
          <para lang="en">
	    Absolute value of a number and if <varname>x</varname> is
	    a complex value the modulus of <varname>x</varname>.  I.e. this
	    the distance of <varname>x</varname> to the origin.  This is equivalent
	    to <userinput>|x|</userinput>.
	  </para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Absolute_value">Wikipedia</ulink>,
	    <ulink url="http://planetmath.org/AbsoluteValue">Planetmath (absolute value)</ulink>,
	    <ulink url="http://planetmath.org/ModulusOfComplexNumber">Planetmath (modulus)</ulink>,
	    <ulink url="http://mathworld.wolfram.com/AbsoluteValue.html">Mathworld (absolute value)</ulink> or
	    <ulink url="http://mathworld.wolfram.com/ComplexModulus.html">Mathworld (complex modulus)</ulink>
for more information.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-Chop"/>Chop</term>
         <listitem>
          <synopsis>Chop (x)</synopsis>
          <para>Заменяет очень малое число нулём.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-ComplexConjugate"/>ComplexConjugate</term>
         <listitem>
          <synopsis lang="en">ComplexConjugate (z)</synopsis>
          <para lang="en">Aliases: <function>conj</function> <function>Conj</function></para>
          <para lang="en">Calculates the complex conjugate of the complex number <varname>z</varname>.  If <varname>z</varname> is a vector or matrix,
all its elements are conjugated.</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Complex_conjugate">Wikipedia</ulink> for more information.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-Denominator"/>Denominator</term>
         <listitem>
          <synopsis>Denominator (x)</synopsis>
          <para>Возвращает знаменатель рационального числа.</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Denominator">Wikipedia</ulink> for more information.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-FractionalPart"/>FractionalPart</term>
         <listitem>
          <synopsis>FractionalPart (x)</synopsis>
          <para>Возвращает дробную часть числа.</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Fractional_part">Wikipedia</ulink> for more information.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-Im"/>Im</term>
         <listitem>
          <synopsis>Im (z)</synopsis>
          <para>Синонимы: <function>ImaginaryPart</function></para>
          <para lang="en">Get the imaginary part of a complex number.  For example <userinput>Re(3+4i)</userinput> yields 4.</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Imaginary_part">Wikipedia</ulink> for more information.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-IntegerQuotient"/>IntegerQuotient</term>
         <listitem>
          <synopsis>IntegerQuotient (m,n)</synopsis>
          <para>Деление без остатка.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-IsComplex"/>IsComplex</term>
         <listitem>
          <synopsis>IsComplex (num)</synopsis>
	  <para lang="en">Check if argument is a complex (non-real) number.  Do note that we really mean nonreal number.  That is,
	  <userinput>IsComplex(3)</userinput> yields false, while
	  <userinput>IsComplex(3-1i)</userinput> yields true.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-IsComplexRational"/>IsComplexRational</term>
         <listitem>
          <synopsis lang="en">IsComplexRational (num)</synopsis>
	  <para lang="en">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."</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-IsFloat"/>IsFloat</term>
         <listitem>
          <synopsis>IsFloat (num)</synopsis>
          <para lang="en">Check if argument is a real floating point number (non-complex).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-IsGaussInteger"/>IsGaussInteger</term>
         <listitem>
          <synopsis lang="en">IsGaussInteger (num)</synopsis>
          <para lang="en">Aliases: <function>IsComplexInteger</function></para>
	  <para lang="en">Check if argument is a possibly complex integer.  That is a complex integer is a number of
		  the form <userinput>n+1i*m</userinput> where <varname>n</varname> and <varname>m</varname>
	  are integers.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-IsInteger"/>IsInteger</term>
         <listitem>
          <synopsis>IsInteger (num)</synopsis>
          <para>Проверяет, является ли аргумент целым числом (не комплексным).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-IsNonNegativeInteger"/>IsNonNegativeInteger</term>
         <listitem>
          <synopsis>IsNonNegativeInteger (num)</synopsis>
          <para lang="en">Check if argument is a non-negative real integer.  That is, either a positive integer or zero.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-IsPositiveInteger"/>IsPositiveInteger</term>
         <listitem>
          <synopsis>IsPositiveInteger (num)</synopsis>
          <para>Синонимы: <function>IsNaturalNumber</function></para>
          <para>Проверяет, является ли аргумент положительным действительным целым числом. Обратите внимание, что мы придерживаемся соглашения о том, что 0 не является натуральным числом.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-IsRational"/>IsRational</term>
         <listitem>
          <synopsis>IsRational (num)</synopsis>
          <para>Проверяет, является ли аргумент рациональным числом (не комплексным). Разумеется, «рациональное» означает просто «не хранящееся в виде числа с плавающей точкой».</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-IsReal"/>IsReal</term>
         <listitem>
          <synopsis>IsReal (num)</synopsis>
          <para>Проверяет, является ли аргумент действительным числом.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-Numerator"/>Numerator</term>
         <listitem>
          <synopsis>Numerator (x)</synopsis>
          <para>Возвращает числитель рационального числа.</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Numerator">Wikipedia</ulink> for more information.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-Re"/>Re</term>
         <listitem>
          <synopsis>Re (z)</synopsis>
          <para>Синонимы: <function>RealPart</function></para>
	  <para lang="en">Get the real part of a complex number.  For example <userinput>Re(3+4i)</userinput> yields 3.</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Real_part">Wikipedia</ulink> for more information.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-Sign"/>Sign</term>
         <listitem>
          <synopsis>Sign (x)</synopsis>
          <para>Синонимы: <function>sign</function></para>
          <para>Возвращает знак числа. То есть, возвращает <literal>-1</literal>, если значение отрицательно, <literal>0</literal>, если рано нулю и <literal>1</literal>, если значение положительно. Если <varname>x</varname> — комплексное число, то <function>Sign</function> возвращает направление на числовой оси (положительное или отрицательное) или 0.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-ceil"/>ceil</term>
         <listitem>
          <synopsis>ceil (x)</synopsis>
          <para>Синонимы: <function>Ceiling</function></para>
	  <para lang="en">Get the lowest integer more than or equal to <varname>n</varname>. Examples:
          <screen lang="en"><prompt>genius&gt;</prompt> <userinput>ceil(1.1)</userinput>
= 2
<prompt>genius&gt;</prompt> <userinput>ceil(-1.1)</userinput>
= -1
</screen>
           </para>
	   <para lang="en">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 <userinput>ceil(420/4.2)</userinput>
		   returns 101 instead of the expected 100.  This is because
		   4.2 is actually very slightly less than 4.2.  Use rational
		   representation <userinput>42/10</userinput> if you want
		   exact arithmetic.
           </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-exp"/>exp</term>
         <listitem>
          <synopsis>exp (x)</synopsis>
          <para>Экспоненциальная функция. Это функция <userinput>e^x</userinput>, где <varname>e</varname> — <link linkend="gel-function-e">основание натурального логарифма</link>.</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Exponential_function">Wikipedia</ulink> or
	    <ulink url="http://planetmath.org/LogarithmFunction">Planetmath</ulink> or
	    <ulink url="http://mathworld.wolfram.com/ExponentialFunction.html">Mathworld</ulink> for more information.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-float"/>float</term>
         <listitem>
          <synopsis>float (x)</synopsis>
          <para>Возвращает представление числа <varname>x</varname> в виде числа с плавающей точкой.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-floor"/>floor</term>
         <listitem>
          <synopsis>floor (x)</synopsis>
          <para>Синонимы: <function>Floor</function></para>
          <para>Возвращает наибольшее целое число, которое меньше или равно <varname>n</varname>.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-ln"/>ln</term>
         <listitem>
          <synopsis>ln (x)</synopsis>
          <para>Натуральный логарифм (логарифм по основанию <varname>e</varname>).</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Natural_logarithm">Wikipedia</ulink> or
	    <ulink url="http://planetmath.org/LogarithmFunction">Planetmath</ulink> or
	    <ulink url="http://mathworld.wolfram.com/NaturalLogarithm.html">Mathworld</ulink> for more information.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-log"/>log</term>
         <listitem>
          <synopsis lang="en">log (x)</synopsis>
          <synopsis lang="en">log (x,b)</synopsis>
	  <para lang="en">Logarithm of <varname>x</varname> base <varname>b</varname> (calls <link linkend="gel-function-DiscreteLog"><function>DiscreteLog</function></link> if in modulo mode), if base is not given, <link linkend="gel-function-e"><varname>e</varname></link> is used.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-log10"/>log10</term>
         <listitem>
          <synopsis>log10 (x)</synopsis>
          <para>Логарифм <varname>x</varname> по основанию 10.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-log2"/>log2</term>
         <listitem>
          <synopsis>log2 (x)</synopsis>
          <para>Синоним: <function>lg</function></para>
          <para>Логарифм <varname>x</varname> по основанию 2.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-max"/>max</term>
         <listitem>
          <synopsis>max (a,args...)</synopsis>
          <para lang="en">Aliases: <function>Max</function> <function>Maximum</function></para>
          <para>Возвращает максимальный из аргументов или элементов матрицы.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-min"/>min</term>
         <listitem>
          <synopsis>min (a,args...)</synopsis>
          <para lang="en">Aliases: <function>Min</function> <function>Minimum</function></para>
          <para>Возвращает минимальный из аргументов или элементов матрицы.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-rand"/>rand</term>
         <listitem>
          <synopsis>rand (size...)</synopsis>
          <para>Генерирует случайное число с плавающей точкой в диапазоне <literal>[0,1)</literal>. Если задан аргумент size, то может возвращать матрицу (если указано два числа) или вектор (если указано одно число) заданной размерности.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-randint"/>randint</term>
         <listitem>
          <synopsis>randint (max,size...)</synopsis>
          <para lang="en">Generate random integer in the range
<literal>[0,max)</literal>.
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,
          <screen lang="en"><prompt>genius&gt;</prompt> <userinput>randint(4)</userinput>
= 3
<prompt>genius&gt;</prompt> <userinput>randint(4,2)</userinput>
=
[0      1]
<prompt>genius&gt;</prompt> <userinput>randint(4,2,3)</userinput>
=
[2      2       1
 0      0       3]
</screen>
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-round"/>round</term>
         <listitem>
          <synopsis>round (x)</synopsis>
          <para>Синонимы: <function>Round</function></para>
          <para>Округляет число.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-sqrt"/>sqrt</term>
         <listitem>
          <synopsis>sqrt (x)</synopsis>
          <para>Синонимы: <function>SquareRoot</function></para>
          <para lang="en">The square root.  When operating modulo some integer will return either a <constant>null</constant> or a vector of the square roots.  Examples:
          <screen lang="en"><prompt>genius&gt;</prompt> <userinput>sqrt(2)</userinput>
= 1.41421356237
<prompt>genius&gt;</prompt> <userinput>sqrt(-1)</userinput>
= 1i
<prompt>genius&gt;</prompt> <userinput>sqrt(4) mod 7</userinput>
=
[2      5]
<prompt>genius&gt;</prompt> <userinput>2*2 mod 7</userinput>
= 4
</screen>
	  </para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Square_root">Wikipedia</ulink> or
	    <ulink url="http://planetmath.org/SquareRoot">Planetmath</ulink> for more information.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-trunc"/>trunc</term>
         <listitem>
          <synopsis>trunc (x)</synopsis>
          <para lang="en">Aliases: <function>Truncate</function> <function>IntegerPart</function></para>
          <para>Усекает число до целого (возвращает целую часть).</para>
         </listitem>
        </varlistentry>

      </variablelist>
    </sect1>

    <sect1 id="genius-gel-function-list-trigonometry">
      <title>Тригонометрические</title>
      <variablelist>
        <varlistentry>
         <term lang="en"><anchor id="gel-function-acos"/>acos</term>
         <listitem>
          <synopsis>acos (x)</synopsis>
          <para>Синонимы: <function>arccos</function></para>
          <para>Функция arccos (арккосинус, обратный косинус).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-acosh"/>acosh</term>
         <listitem>
          <synopsis>acosh (x)</synopsis>
          <para>Синонимы: <function>arccosh</function></para>
          <para>Функция arccosh (обратный гиперболический косинус).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-acot"/>acot</term>
         <listitem>
          <synopsis>acot (x)</synopsis>
          <para>Синонимы: <function>arccot</function></para>
          <para>Фунция arccot (арккотангенс, обратный котангенс).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-acoth"/>acoth</term>
         <listitem>
          <synopsis>acoth (x)</synopsis>
          <para>Синонимы: <function>arccoth</function></para>
          <para>Функция arccoth (обратный гиперболический котангенс).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-acsc"/>acsc</term>
         <listitem>
          <synopsis>acsc (x)</synopsis>
          <para>Синонимы: <function>arccsc</function></para>
          <para>Обратный косеканс.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-acsch"/>acsch</term>
         <listitem>
          <synopsis>acsch (x)</synopsis>
          <para>Синонимы: <function>arccsch</function></para>
          <para>Обратный гиперболический косеканс.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-asec"/>asec</term>
         <listitem>
          <synopsis>asec (x)</synopsis>
          <para>Синонимы: <function>arcsec</function></para>
          <para>Обратный секанс.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-asech"/>asech</term>
         <listitem>
          <synopsis>asech (x)</synopsis>
          <para>Синонимы: <function>arcsech</function></para>
          <para>Обратный гиперболический секанс.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-asin"/>asin</term>
         <listitem>
          <synopsis>asin (x)</synopsis>
          <para>Синонимы: <function>arcsin</function></para>
          <para>Функция arcsin (арксинус, обратный синус).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-asinh"/>asinh</term>
         <listitem>
          <synopsis>asinh (x)</synopsis>
          <para>Синонимы: <function>arcsinh</function></para>
          <para>Фунция arcsinh (обратный гиперболический синус).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-atan"/>atan</term>
         <listitem>
          <synopsis>atan (x)</synopsis>
          <para>Синонимы: <function>arctan</function></para>
          <para>Вычисляет функцию arctan (арктангенс, обратный тангенс).</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Arctangent">Wikipedia</ulink> or
	    <ulink url="http://mathworld.wolfram.com/InverseTangent.html">Mathworld</ulink> for more information.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-atanh"/>atanh</term>
         <listitem>
          <synopsis>atanh (x)</synopsis>
          <para>Синонимы: <function>arctanh</function></para>
          <para>Функция arctanh (обратный гиперболический тангенс).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-atan2"/>atan2</term>
         <listitem>
          <synopsis>atan2 (y, x)</synopsis>
          <para>Синонимы: <function>arctan2</function></para>
          <para lang="en">Calculates the arctan2 function.  If
	  <userinput>x&gt;0</userinput> then it returns
	  <userinput>atan(y/x)</userinput>.  If <userinput>x&lt;0</userinput>
	  then it returns <userinput>sign(y) * (pi - atan(|y/x|)</userinput>.
	  When <userinput>x=0</userinput> it returns <userinput>sign(y) *
	  pi/2</userinput>.  <userinput>atan2(0,0)</userinput> returns 0
	  rather than failing.
	  </para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Atan2">Wikipedia</ulink> or
	    <ulink url="http://mathworld.wolfram.com/InverseTangent.html">Mathworld</ulink> for more information.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-cos"/>cos</term>
         <listitem>
          <synopsis>cos (x)</synopsis>
          <para>Вычисляет косинус.</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Trigonometric_functions">Wikipedia</ulink> or
	    <ulink url="http://planetmath.org/DefinitionsInTrigonometry">Planetmath</ulink> for more information.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-cosh"/>cosh</term>
         <listitem>
          <synopsis>cosh (x)</synopsis>
          <para>Вычисляет гиперболический косинус.</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Hyperbolic_function">Wikipedia</ulink> or
	    <ulink url="http://planetmath.org/HyperbolicFunctions">Planetmath</ulink> for more information.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-cot"/>cot</term>
         <listitem>
          <synopsis>cot (x)</synopsis>
          <para>Вычисляет котангенс.</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Trigonometric_functions">Wikipedia</ulink> or
	    <ulink url="http://planetmath.org/DefinitionsInTrigonometry">Planetmath</ulink> for more information.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-coth"/>coth</term>
         <listitem>
          <synopsis>coth (x)</synopsis>
          <para>Вычисляет гиперболический котангенс.</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Hyperbolic_function">Wikipedia</ulink> or
	    <ulink url="http://planetmath.org/HyperbolicFunctions">Planetmath</ulink> for more information.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-csc"/>csc</term>
         <listitem>
          <synopsis>csc (x)</synopsis>
          <para>Вычисляет косеканс.</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Trigonometric_functions">Wikipedia</ulink> or
	    <ulink url="http://planetmath.org/DefinitionsInTrigonometry">Planetmath</ulink> for more information.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-csch"/>csch</term>
         <listitem>
          <synopsis>csch (x)</synopsis>
          <para>Вычисляет гиперболический косеканс.</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Hyperbolic_function">Wikipedia</ulink> or
	    <ulink url="http://planetmath.org/HyperbolicFunctions">Planetmath</ulink> for more information.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-sec"/>sec</term>
         <listitem>
          <synopsis>sec (x)</synopsis>
          <para>Вычисляет секанс.</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Trigonometric_functions">Wikipedia</ulink> or
	    <ulink url="http://planetmath.org/DefinitionsInTrigonometry">Planetmath</ulink> for more information.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-sech"/>sech</term>
         <listitem>
          <synopsis>sech (x)</synopsis>
          <para>Вычисляет гиперболический секанс.</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Hyperbolic_function">Wikipedia</ulink> or
	    <ulink url="http://planetmath.org/HyperbolicFunctions">Planetmath</ulink> for more information.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-sin"/>sin</term>
         <listitem>
          <synopsis>sin (x)</synopsis>
          <para>Вычисляет синус.</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Trigonometric_functions">Wikipedia</ulink> or
	    <ulink url="http://planetmath.org/DefinitionsInTrigonometry">Planetmath</ulink> for more information.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-sinh"/>sinh</term>
         <listitem>
          <synopsis>sinh (x)</synopsis>
          <para>Вычисляет гиперболический синус.</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Hyperbolic_function">Wikipedia</ulink> or
	    <ulink url="http://planetmath.org/HyperbolicFunctions">Planetmath</ulink> for more information.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-tan"/>tan</term>
         <listitem>
          <synopsis>tan (x)</synopsis>
          <para>Вычисляет тангенс.</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Trigonometric_functions">Wikipedia</ulink> or
	    <ulink url="http://planetmath.org/DefinitionsInTrigonometry">Planetmath</ulink> for more information.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-tanh"/>tanh</term>
         <listitem>
          <synopsis>tanh (x)</synopsis>
          <para>Вычисляет гиперболический тангенс.</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Hyperbolic_function">Wikipedia</ulink> or
	    <ulink url="http://planetmath.org/HyperbolicFunctions">Planetmath</ulink> for more information.
	  </para>
         </listitem>
        </varlistentry>

      </variablelist>
    </sect1>

    <sect1 id="genius-gel-function-list-number-theory">
      <title>Теория чисел</title>
      <variablelist>
        <varlistentry>
         <term lang="en"><anchor id="gel-function-AreRelativelyPrime"/>AreRelativelyPrime</term>
         <listitem>
          <synopsis lang="en">AreRelativelyPrime (a,b)</synopsis>
          <para lang="en">
	    Are the real integers <varname>a</varname> and <varname>b</varname> relatively prime?
	    Returns <constant>true</constant> or <constant>false</constant>.
	  </para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Coprime_integers">Wikipedia</ulink> or
	    <ulink url="http://planetmath.org/RelativelyPrime">Planetmath</ulink> or
	    <ulink url="http://mathworld.wolfram.com/RelativelyPrime.html">Mathworld</ulink> for more information.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-BernoulliNumber"/>BernoulliNumber</term>
         <listitem>
          <synopsis lang="en">BernoulliNumber (n)</synopsis>
          <para lang="en">Return the <varname>n</varname>th Bernoulli number.</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Bernoulli_number">Wikipedia</ulink> or
	    <ulink url="http://mathworld.wolfram.com/BernoulliNumber.html">Mathworld</ulink> for more information.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-ChineseRemainder"/>ChineseRemainder</term>
         <listitem>
          <synopsis lang="en">ChineseRemainder (a,m)</synopsis>
          <para lang="en">Aliases: <function>CRT</function></para>
	  <para lang="en">Find the <varname>x</varname> that solves the system given by
		the vector <varname>a</varname> and modulo the elements of
		<varname>m</varname>, using the Chinese Remainder Theorem.
	  </para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Chinese_remainder_theorem">Wikipedia</ulink> or
	    <ulink url="http://planetmath.org/ChineseRemainderTheorem">Planetmath</ulink> or
	    <ulink url="http://mathworld.wolfram.com/ChineseRemainderTheorem.html">Mathworld</ulink> for more information.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-CombineFactorizations"/>CombineFactorizations</term>
         <listitem>
          <synopsis lang="en">CombineFactorizations (a,b)</synopsis>
	  <para lang="en">Given two factorizations, give the factorization of the
		product.</para>
	  <para lang="en">See <link linkend="gel-function-Factorize">Factorize</link>.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-ConvertFromBase"/>ConvertFromBase</term>
         <listitem>
          <synopsis lang="en">ConvertFromBase (v,b)</synopsis>
          <para lang="en">Convert a vector of values indicating powers of b to a number.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-ConvertToBase"/>ConvertToBase</term>
         <listitem>
          <synopsis lang="en">ConvertToBase (n,b)</synopsis>
          <para lang="en">Convert a number to a vector of powers for elements in base <varname>b</varname>.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-DiscreteLog"/>DiscreteLog</term>
         <listitem>
          <synopsis lang="en">DiscreteLog (n,b,q)</synopsis>
          <para lang="en">Find discrete log of <varname>n</varname> base <varname>b</varname> in
	    F<subscript>q</subscript>, the finite field of order <varname>q</varname>, where <varname>q</varname>
	    is a prime, using the Silver-Pohlig-Hellman algorithm.</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Discrete_logarithm">Wikipedia</ulink>,
	    <ulink url="http://planetmath.org/DiscreteLogarithm">Planetmath</ulink>, or
	    <ulink url="http://mathworld.wolfram.com/DiscreteLogarithm.html">Mathworld</ulink> for more information.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-Divides"/>Divides</term>
         <listitem>
          <synopsis>Divides (m,n)</synopsis>
          <para>Проверяет делимость (делится ли <varname>n</varname> на <varname>m</varname>).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-EulerPhi"/>EulerPhi</term>
         <listitem>
          <synopsis lang="en">EulerPhi (n)</synopsis>
          <para lang="en">
	    Compute the Euler phi function for <varname>n</varname>, that is
	    the number of integers between 1 and <varname>n</varname>
	    relatively prime to <varname>n</varname>.
	  </para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Euler_phi">Wikipedia</ulink>,
	    <ulink url="http://planetmath.org/EulerPhifunction">Planetmath</ulink>, or
	    <ulink url="http://mathworld.wolfram.com/TotientFunction.html">Mathworld</ulink> for more information.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-ExactDivision"/>ExactDivision</term>
         <listitem>
          <synopsis>ExactDivision (n,d)</synopsis>
          <para lang="en">
	    Return <userinput>n/d</userinput> but only if <varname>d</varname>
	    divides <varname>n</varname>.  If <varname>d</varname>
	    does not divide <varname>n</varname> then this function returns
	    garbage.  This is a lot faster for very large numbers
	    than the operation <userinput>n/d</userinput>, but it is only
	    useful if you know that the division is exact.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-Factorize"/>Factorize</term>
         <listitem>
          <synopsis lang="en">Factorize (n)</synopsis>
          <para lang="en">
	    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:
	    <screen lang="en"><prompt>genius&gt;</prompt> <userinput>Factorize(11*11*13)</userinput>
=
[1      11      13
 1      2       1]</screen>
	  </para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Factorization">Wikipedia</ulink> for more information.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-Factors"/>Factors</term>
         <listitem>
          <synopsis lang="en">Factors (n)</synopsis>
          <para lang="en">
	    Return all factors of <varname>n</varname> 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)
	    <programlisting lang="en">for n=1 to 1000 do (
    if MatrixSum (Factors(n)) == 2*n then
        print(n)
)
</programlisting>
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-FermatFactorization"/>FermatFactorization</term>
         <listitem>
          <synopsis lang="en">FermatFactorization (n,tries)</synopsis>
          <para lang="en">
	    Attempt Fermat factorization of <varname>n</varname> into
	    <userinput>(t-s)*(t+s)</userinput>, returns <varname>t</varname>
	    and <varname>s</varname> as a vector if possible, <constant>null</constant> otherwise.
	    <varname>tries</varname> specifies the number of tries before
	    giving up.
	  </para>
          <para lang="en">
	    This is a fairly good factorization if your number is the product
	    of two factors that are very close to each other.
	  </para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Fermat_factorization">Wikipedia</ulink> for more information.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-FindPrimitiveElementMod"/>FindPrimitiveElementMod</term>
         <listitem>
          <synopsis lang="en">FindPrimitiveElementMod (q)</synopsis>
          <para lang="en">Find the first primitive element in F<subscript>q</subscript>, the finite
group of order <varname>q</varname>.  Of course <varname>q</varname> must be a prime.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-FindRandomPrimitiveElementMod"/>FindRandomPrimitiveElementMod</term>
         <listitem>
          <synopsis lang="en">FindRandomPrimitiveElementMod (q)</synopsis>
          <para lang="en">Find a random primitive element in F<subscript>q</subscript>, the finite
group of order <varname>q</varname> (q must be a prime).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-IndexCalculus"/>IndexCalculus</term>
         <listitem>
          <synopsis lang="en">IndexCalculus (n,b,q,S)</synopsis>
          <para lang="en">Compute discrete log base <varname>b</varname> of n in F<subscript>q</subscript>, the finite
group of order <varname>q</varname> (<varname>q</varname> a prime), using the
factor base <varname>S</varname>.  <varname>S</varname> should be a column of
primes possibly with second column precalculated by
<link linkend="gel-function-IndexCalculusPrecalculation"><function>IndexCalculusPrecalculation</function></link>.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-IndexCalculusPrecalculation"/>IndexCalculusPrecalculation</term>
         <listitem>
          <synopsis lang="en">IndexCalculusPrecalculation (b,q,S)</synopsis>
	  <para lang="en">Run the precalculation step of
		  <link linkend="gel-function-IndexCalculus"><function>IndexCalculus</function></link> for logarithms base <varname>b</varname> in
F<subscript>q</subscript>, the finite group of order <varname>q</varname>
(<varname>q</varname> a prime), for the factor base <varname>S</varname> (where
<varname>S</varname> is a column vector of primes).  The logs will be
precalculated and returned in the second column.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-IsEven"/>IsEven</term>
         <listitem>
          <synopsis>IsEven (n)</synopsis>
          <para>Проверяет, является ли целое число чётным.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-IsMersennePrimeExponent"/>IsMersennePrimeExponent</term>
         <listitem>
          <synopsis lang="en">IsMersennePrimeExponent (p)</synopsis>
          <para lang="en">
	    Tests if a positive integer <varname>p</varname> is a
	    Mersenne prime exponent.  That is if 
            2<superscript>p</superscript>-1 is a prime.  It does this
	    by looking it up in a table of known values, which is relatively
	    short.
	    See also
	    <link linkend="gel-function-MersennePrimeExponents">MersennePrimeExponents</link>
	    and
	    <link linkend="gel-function-LucasLehmer">LucasLehmer</link>.
	  </para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Mersenne_prime">Wikipedia</ulink>,
	    <ulink url="http://planetmath.org/MersenneNumbers">Planetmath</ulink>,
	    <ulink url="http://mathworld.wolfram.com/MersennePrime.html">Mathworld</ulink> or 
	    <ulink url="http://www.mersenne.org/">GIMPS</ulink>
 for more information.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-IsNthPower"/>IsNthPower</term>
         <listitem>
          <synopsis lang="en">IsNthPower (m,n)</synopsis>
          <para lang="en">
	    Tests if a rational number <varname>m</varname> is a perfect
	    <varname>n</varname>th power.  See also
	    <link linkend="gel-function-IsPerfectPower">IsPerfectPower</link>
	    and
	    <link linkend="gel-function-IsPerfectSquare">IsPerfectSquare</link>.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-IsOdd"/>IsOdd</term>
         <listitem>
          <synopsis>IsOdd (n)</synopsis>
          <para>Проверяет, является ли целое число нечётным.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-IsPerfectPower"/>IsPerfectPower</term>
         <listitem>
          <synopsis lang="en">IsPerfectPower (n)</synopsis>
          <para lang="en">Check an integer for being any perfect power, a<superscript>b</superscript>.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-IsPerfectSquare"/>IsPerfectSquare</term>
         <listitem>
          <synopsis lang="en">IsPerfectSquare (n)</synopsis>
          <para lang="en">
	    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.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-IsPrime"/>IsPrime</term>
         <listitem>
          <synopsis lang="en">IsPrime (n)</synopsis>
          <para lang="en">
	    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
	    <link linkend="gel-function-IsPrimeMillerRabinReps">
	    <function>IsPrimeMillerRabinReps</function></link>.  That
	    is the probability of false positive is 1/4 to the power
	    <function>IsPrimeMillerRabinReps</function>.  The default
	    value of 22 yields a probability of about 5.7e-14.
	  </para>
          <para lang="en">
	    If <constant>false</constant> 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 
	    <link linkend="gel-function-MillerRabinTestSure">
	    <function>MillerRabinTestSure</function></link> but it may take
	    a lot longer.
	  </para>
          <para lang="en">
	    See
	    <ulink url="http://planetmath.org/PrimeNumber">Planetmath</ulink> or
	    <ulink url="http://mathworld.wolfram.com/PrimeNumber.html">Mathworld</ulink> for more information.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-IsPrimitiveMod"/>IsPrimitiveMod</term>
         <listitem>
          <synopsis lang="en">IsPrimitiveMod (g,q)</synopsis>
          <para lang="en">Check if <varname>g</varname> is primitive in F<subscript>q</subscript>, the finite
group of order <varname>q</varname>, where <varname>q</varname> is a prime.  If <varname>q</varname> is not prime results are bogus.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-IsPrimitiveModWithPrimeFactors"/>IsPrimitiveModWithPrimeFactors</term>
         <listitem>
          <synopsis lang="en">IsPrimitiveModWithPrimeFactors (g,q,f)</synopsis>
          <para lang="en">Check if <varname>g</varname> is primitive in F<subscript>q</subscript>, the finite
group of order <varname>q</varname>, where <varname>q</varname> is a prime and
<varname>f</varname> is a vector of prime factors of <varname>q</varname>-1.
If <varname>q</varname> is not prime results are bogus.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-IsPseudoprime"/>IsPseudoprime</term>
         <listitem>
          <synopsis lang="en">IsPseudoprime (n,b)</synopsis>
          <para lang="en">If <varname>n</varname> is a pseudoprime base <varname>b</varname> but not a prime,
		  that is if <userinput>b^(n-1) == 1 mod n</userinput>.  This calls the <link linkend="gel-function-PseudoprimeTest"><function>PseudoprimeTest</function></link></para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-IsStrongPseudoprime"/>IsStrongPseudoprime</term>
         <listitem>
          <synopsis lang="en">IsStrongPseudoprime (n,b)</synopsis>
          <para lang="en">Test if <varname>n</varname> is a strong pseudoprime to base <varname>b</varname> but not a prime.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-Jacobi"/>Jacobi</term>
         <listitem>
          <synopsis>Jacobi (a,b)</synopsis>
          <para>Синонимы: <function>JacobiSymbol</function></para>
          <para>Вычисляет символ Якоби (a/b) (b должно быть нечётным).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-JacobiKronecker"/>JacobiKronecker</term>
         <listitem>
          <synopsis>JacobiKronecker (a,b)</synopsis>
          <para>Синонимы: <function>JacobiKroneckerSymbol</function></para>
          <para>Вычисляет символ Якоби (a/b) с дополнением Кронекера (a/2)=(2/a), если нечётное или (a/2)=0, если чётное.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-LeastAbsoluteResidue"/>LeastAbsoluteResidue</term>
         <listitem>
          <synopsis lang="en">LeastAbsoluteResidue (a,n)</synopsis>
          <para lang="en">Return the residue of <varname>a</varname> mod <varname>n</varname> with the least absolute value (in the interval -n/2 to n/2).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-Legendre"/>Legendre</term>
         <listitem>
          <synopsis lang="en">Legendre (a,p)</synopsis>
          <para lang="en">Aliases: <function>LegendreSymbol</function></para>
          <para lang="en">Calculate the Legendre symbol (a/p).</para>
          <para lang="en">
	    See
	    <ulink url="http://planetmath.org/LegendreSymbol">Planetmath</ulink> or
	    <ulink url="http://mathworld.wolfram.com/LegendreSymbol.html">Mathworld</ulink> for more information.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-LucasLehmer"/>LucasLehmer</term>
         <listitem>
          <synopsis lang="en">LucasLehmer (p)</synopsis>
          <para lang="en">Test if 2<superscript>p</superscript>-1 is a Mersenne prime using the Lucas-Lehmer test.
	    See also
	    <link linkend="gel-function-MersennePrimeExponents">MersennePrimeExponents</link>
	    and
	    <link linkend="gel-function-IsMersennePrimeExponent">IsMersennePrimeExponent</link>.
          </para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Lucas%E2%80%93Lehmer_primality_test">Wikipedia</ulink>,
	    <ulink url="http://planetmath.org/LucasLhemer">Planetmath</ulink>, or
	    <ulink url="http://mathworld.wolfram.com/Lucas-LehmerTest.html">Mathworld</ulink> for more information.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-LucasNumber"/>LucasNumber</term>
         <listitem>
          <synopsis lang="en">LucasNumber (n)</synopsis>
          <para lang="en">Returns the <varname>n</varname>th Lucas number.</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Lucas_number">Wikipedia</ulink>,
	    <ulink url="http://planetmath.org/LucasNumbers">Planetmath</ulink>, or
	    <ulink url="http://mathworld.wolfram.com/LucasNumber.html">Mathworld</ulink> for more information.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-MaximalPrimePowerFactors"/>MaximalPrimePowerFactors</term>
         <listitem>
          <synopsis lang="en">MaximalPrimePowerFactors (n)</synopsis>
          <para lang="en">Return all maximal prime power factors of a number.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-MersennePrimeExponents"/>MersennePrimeExponents</term>
         <listitem>
          <synopsis lang="en">MersennePrimeExponents</synopsis>
          <para lang="en">
	    A vector of known Mersenne prime exponents, that is
	    a list of positive integers
	    <varname>p</varname> such that
            2<superscript>p</superscript>-1 is a prime.
	    See also
	    <link linkend="gel-function-IsMersennePrimeExponent">IsMersennePrimeExponent</link>
	    and
	    <link linkend="gel-function-LucasLehmer">LucasLehmer</link>.
	  </para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Mersenne_prime">Wikipedia</ulink>,
	    <ulink url="http://planetmath.org/MersenneNumbers">Planetmath</ulink>,
	    <ulink url="http://mathworld.wolfram.com/MersennePrime.html">Mathworld</ulink> or 
	    <ulink url="http://www.mersenne.org/">GIMPS</ulink>
 for more information.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-MillerRabinTest"/>MillerRabinTest</term>
         <listitem>
          <synopsis lang="en">MillerRabinTest (n,reps)</synopsis>
          <para lang="en">
	    Use the Miller-Rabin primality test on <varname>n</varname>,
	    <varname>reps</varname> number of times.  The probability of false
	    positive is <userinput>(1/4)^reps</userinput>.  It is probably
	    usually better to use
	    <link linkend="gel-function-IsPrime">
	    <function>IsPrime</function></link> since that is faster and
	    better on smaller integers.
	  </para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Miller%E2%80%93Rabin_primality_test">Wikipedia</ulink> or
	    <ulink url="http://planetmath.org/MillerRabinPrimeTest">Planetmath</ulink> or
	    <ulink url="http://mathworld.wolfram.com/Rabin-MillerStrongPseudoprimeTest.html">Mathworld</ulink> for more information.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-MillerRabinTestSure"/>MillerRabinTestSure</term>
         <listitem>
          <synopsis lang="en">MillerRabinTestSure (n)</synopsis>
          <para lang="en">
	    Use the Miller-Rabin primality test on <varname>n</varname> with
	    enough bases that assuming the Generalized Riemann Hypothesis the
	    result is deterministic.
	  </para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Miller%E2%80%93Rabin_primality_test">Wikipedia</ulink>,
	    <ulink url="http://planetmath.org/MillerRabinPrimeTest">Planetmath</ulink>, or
	    <ulink url="http://mathworld.wolfram.com/Rabin-MillerStrongPseudoprimeTest.html">Mathworld</ulink> for more information.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-ModInvert"/>ModInvert</term>
         <listitem>
          <synopsis lang="en">ModInvert (n,m)</synopsis>
          <para lang="en">Returns inverse of n mod m.</para>
          <para lang="en">
	    See
	    <ulink url="http://mathworld.wolfram.com/ModularInverse.html">Mathworld</ulink> for more information.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-MoebiusMu"/>MoebiusMu</term>
         <listitem>
          <synopsis lang="en">MoebiusMu (n)</synopsis>
          <para lang="en">
	    Return the Moebius mu function evaluated in <varname>n</varname>.
	    That is, it returns 0 if <varname>n</varname> is not a product
	    of distinct primes and <userinput>(-1)^k</userinput> if it is
	    a product of <varname>k</varname> distinct primes.
	  </para>
          <para lang="en">
	    See
	    <ulink url="http://planetmath.org/MoebiusFunction">Planetmath</ulink> or
	    <ulink url="http://mathworld.wolfram.com/MoebiusFunction.html">Mathworld</ulink> for more information.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-NextPrime"/>NextPrime</term>
         <listitem>
          <synopsis lang="en">NextPrime (n)</synopsis>
          <para lang="en">
	    Returns the least prime greater than <varname>n</varname>.
	    Negatives of primes are considered prime and so to get the
	    previous prime you can use <userinput>-NextPrime(-n)</userinput>.
	  </para>
          <para lang="en">
	    This function uses the GMPs <function>mpz_nextprime</function>,
	    which in turn uses the probabilistic Miller-Rabin test
	    (See also <link linkend="gel-function-MillerRabinTest"><function>MillerRabinTest</function></link>).
	    The probability
	    of false positive is not tunable, but is low enough
	    for all practical purposes.
	  </para>
          <para lang="en">
	    See
	    <ulink url="http://planetmath.org/PrimeNumber">Planetmath</ulink> or
	    <ulink url="http://mathworld.wolfram.com/PrimeNumber.html">Mathworld</ulink> for more information.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-PadicValuation"/>PadicValuation</term>
         <listitem>
          <synopsis lang="en">PadicValuation (n,p)</synopsis>
          <para lang="en">Returns the p-adic valuation (number of trailing zeros in base <varname>p</varname>).</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/P-adic_order">Wikipedia</ulink> or
	    <ulink url="http://planetmath.org/PAdicValuation">Planetmath</ulink> for more information.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-PowerMod"/>PowerMod</term>
         <listitem>
          <synopsis lang="en">PowerMod (a,b,m)</synopsis>
          <para lang="en">
	    Compute <userinput>a^b mod m</userinput>.  The
	    <varname>b</varname>'s power of <varname>a</varname> modulo
	    <varname>m</varname>.  It is not necessary to use this function
	    as it is automatically used in modulo mode.  Hence
	    <userinput>a^b mod m</userinput> is just as fast.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-Prime"/>Prime</term>
         <listitem>
          <synopsis lang="en">Prime (n)</synopsis>
          <para lang="en">Aliases: <function>prime</function></para>
          <para lang="en">Return the <varname>n</varname>th prime (up to a limit).</para>
          <para lang="en">
	    See
	    <ulink url="http://planetmath.org/PrimeNumber">Planetmath</ulink> or
	    <ulink url="http://mathworld.wolfram.com/PrimeNumber.html">Mathworld</ulink> for more information.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-PrimeFactors"/>PrimeFactors</term>
         <listitem>
          <synopsis lang="en">PrimeFactors (n)</synopsis>
          <para lang="en">Return all prime factors of a number as a vector.</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Prime_factor">Wikipedia</ulink> or
	    <ulink url="http://mathworld.wolfram.com/PrimeFactor.html">Mathworld</ulink> for more information.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-PseudoprimeTest"/>PseudoprimeTest</term>
         <listitem>
          <synopsis lang="en">PseudoprimeTest (n,b)</synopsis>
	  <para lang="en">Pseudoprime test, returns <constant>true</constant> if and only if
		<userinput>b^(n-1) == 1  mod n</userinput></para>
          <para lang="en">
	    See
	    <ulink url="http://planetmath.org/Pseudoprime">Planetmath</ulink> or
	    <ulink url="http://mathworld.wolfram.com/Pseudoprime.html">Mathworld</ulink> for more information.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-RemoveFactor"/>RemoveFactor</term>
         <listitem>
          <synopsis lang="en">RemoveFactor (n,m)</synopsis>
          <para lang="en">Removes all instances of the factor <varname>m</varname> from the number <varname>n</varname>.  That is divides by the largest power of <varname>m</varname>, that divides <varname>n</varname>.</para>
          <para lang="en">
	    See
	    <ulink url="http://planetmath.org/Divisibility">Planetmath</ulink> or
	    <ulink url="http://mathworld.wolfram.com/Factor.html">Mathworld</ulink> for more information.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-SilverPohligHellmanWithFactorization"/>SilverPohligHellmanWithFactorization</term>
         <listitem>
          <synopsis lang="en">SilverPohligHellmanWithFactorization (n,b,q,f)</synopsis>
          <para lang="en">Find discrete log of <varname>n</varname> base <varname>b</varname> in F<subscript>q</subscript>, the finite group of order <varname>q</varname>, where <varname>q</varname> is a prime using the Silver-Pohlig-Hellman algorithm, given <varname>f</varname> being the factorization of <varname>q</varname>-1.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-SqrtModPrime"/>SqrtModPrime</term>
         <listitem>
          <synopsis lang="en">SqrtModPrime (n,p)</synopsis>
          <para lang="en">Find square root of <varname>n</varname> modulo <varname>p</varname> (where <varname>p</varname> is a prime).  Null is returned if not a quadratic residue.</para>
          <para lang="en">
	    See
	    <ulink url="http://planetmath.org/QuadraticResidue">Planetmath</ulink> or
	    <ulink url="http://mathworld.wolfram.com/QuadraticResidue.html">Mathworld</ulink> for more information.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-StrongPseudoprimeTest"/>StrongPseudoprimeTest</term>
         <listitem>
          <synopsis lang="en">StrongPseudoprimeTest (n,b)</synopsis>
          <para lang="en">Run the strong pseudoprime test base <varname>b</varname> on <varname>n</varname>.</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Strong_pseudoprime">Wikipedia</ulink>,
	    <ulink url="http://planetmath.org/StrongPseudoprime">Planetmath</ulink>, or
	    <ulink url="http://mathworld.wolfram.com/StrongPseudoprime.html">Mathworld</ulink> for more information.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-gcd"/>gcd</term>
         <listitem>
          <synopsis lang="en">gcd (a,args...)</synopsis>
          <para lang="en">Aliases: <function>GCD</function></para>
          <para lang="en">
	    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.
	  </para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Greatest_common_divisor">Wikipedia</ulink>,
	    <ulink url="http://planetmath.org/GreatestCommonDivisor">Planetmath</ulink>, or
	    <ulink url="http://mathworld.wolfram.com/GreatestCommonDivisor.html">Mathworld</ulink> for more information.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-lcm"/>lcm</term>
         <listitem>
          <synopsis lang="en">lcm (a,args...)</synopsis>
          <para lang="en">Aliases: <function>LCM</function></para>
          <para lang="en">
	    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.    
	  </para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Least_common_multiple">Wikipedia</ulink>,
	    <ulink url="http://planetmath.org/LeastCommonMultiple">Planetmath</ulink>, or
	    <ulink url="http://mathworld.wolfram.com/LeastCommonMultiple.html">Mathworld</ulink> for more information.
	  </para>
         </listitem>
        </varlistentry>

      </variablelist>
    </sect1>

    <sect1 id="genius-gel-function-list-matrix">
      <title>Операции с матрицами</title>
      <variablelist>
        <varlistentry>
         <term lang="en"><anchor id="gel-function-AppendElement"/>AppendElement</term>
         <listitem>
          <synopsis lang="en">AppendElement (v,elt)</synopsis>
	  <para lang="en">Append an element to a vector and return the vector.  No expansion is done.  Normally
		  a row vector is built if starting from <constant>null</constant> or a 1-by-1 matrix,
		  but if given a column vector it will properly build a column vector.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-ApplyOverMatrix"/>ApplyOverMatrix</term>
         <listitem>
          <synopsis>ApplyOverMatrix (a,func)</synopsis>
          <para>Применяет функцию к каждому элементу матрицы и возвращает матрицу результатов.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-ApplyOverMatrix2"/>ApplyOverMatrix2</term>
         <listitem>
          <synopsis>ApplyOverMatrix2 (a,b,func)</synopsis>
          <para>Применяет функцию к каждому элементу двух матриц (или 1 значению и 1 матрице) и возвращает матрицу результатов.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-ColumnsOf"/>ColumnsOf</term>
         <listitem>
          <synopsis>ColumnsOf (M)</synopsis>
          <para>Возвращает столбцы матрицы в виде горизонтального вектора.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-ComplementSubmatrix"/>ComplementSubmatrix</term>
         <listitem>
          <synopsis lang="en">ComplementSubmatrix (m,r,c)</synopsis>
          <para lang="en">Remove column(s) and row(s) from a matrix.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-CompoundMatrix"/>CompoundMatrix</term>
         <listitem>
          <synopsis lang="en">CompoundMatrix (k,A)</synopsis>
          <para lang="en">Calculate the kth compound matrix of A.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-CountZeroColumns"/>CountZeroColumns</term>
         <listitem>
          <synopsis lang="en">CountZeroColumns (M)</synopsis>
          <para lang="en">
	   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 <link linkend="gel-function-cref"><function>cref</function></link>
	   and <link linkend="gel-function-Nullity"><function>Nullity</function></link>.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-DeleteColumn"/>DeleteColumn</term>
         <listitem>
          <synopsis>DeleteColumn (M,столбец)</synopsis>
          <para>Удаляет столбец матрицы.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-DeleteRow"/>DeleteRow</term>
         <listitem>
          <synopsis>DeleteRow (M,строка)</synopsis>
          <para>Удаляет строку матрицы.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-DiagonalOf"/>DiagonalOf</term>
         <listitem>
          <synopsis lang="en">DiagonalOf (M)</synopsis>
          <para lang="en">Gets the diagonal entries of a matrix as a column vector.</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Diagonal_of_a_matrix#Matrices">Wikipedia</ulink> for more information.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-DotProduct"/>DotProduct</term>
         <listitem>
          <synopsis lang="en">DotProduct (u,v)</synopsis>
	  <para lang="en">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 <link linkend="gel-function-HermitianProduct">HermitianProduct</link> for the standard sesquilinear inner product.</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Dot_product">Wikipedia</ulink> or
	    <ulink url="http://planetmath.org/DotProduct">Planetmath</ulink> for more information.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-ExpandMatrix"/>ExpandMatrix</term>
         <listitem>
          <synopsis lang="en">ExpandMatrix (M)</synopsis>
          <para lang="en">
	    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.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-HermitianProduct"/>HermitianProduct</term>
         <listitem>
          <synopsis lang="en">HermitianProduct (u,v)</synopsis>
          <para lang="en">Aliases: <function>InnerProduct</function></para>
          <para lang="en">Get the Hermitian product of two vectors.  The vectors must be of the same size.  This is a sesquilinear form using the identity matrix.</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Sesquilinear_form">Wikipedia</ulink> or
	    <ulink url="http://mathworld.wolfram.com/HermitianInnerProduct.html">Mathworld</ulink> for more information.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-I"/>I</term>
         <listitem>
          <synopsis lang="en">I (n)</synopsis>
          <para lang="en">Aliases: <function>eye</function></para>
	  <para lang="en">Return an identity matrix of a given size, that is <varname>n</varname> by <varname>n</varname>.  If <varname>n</varname> is zero, returns <constant>null</constant>.</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Identity_matrix">Wikipedia</ulink> or
	    <ulink url="http://planetmath.org/IdentityMatrix">Planetmath</ulink> for more information.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-IndexComplement"/>IndexComplement</term>
         <listitem>
          <synopsis lang="en">IndexComplement (vec,msize)</synopsis>
          <para lang="en">Return the index complement of a vector of indexes.  Everything is one based.  For example for vector <userinput>[2,3]</userinput> and size
<userinput>5</userinput>, we return <userinput>[1,4,5]</userinput>.  If
<varname>msize</varname> is 0, we always return <constant>null</constant>.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-IsDiagonal"/>IsDiagonal</term>
         <listitem>
          <synopsis>IsDiagonal (M)</synopsis>
          <para>Является ли матрица диагональной.</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Diagonal_matrix">Wikipedia</ulink> or
	    <ulink url="http://planetmath.org/DiagonalMatrix">Planetmath</ulink> for more information.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-IsIdentity"/>IsIdentity</term>
         <listitem>
          <synopsis lang="en">IsIdentity (x)</synopsis>
          <para lang="en">Check if a matrix is the identity matrix.  Automatically returns <constant>false</constant>
	    if the matrix is not square.  Also works on numbers, in which
	    case it is equivalent to <userinput>x==1</userinput>.  When <varname>x</varname> is
	    <constant>null</constant> (we could think of that as a 0 by 0 matrix),
	    no error is generated and <constant>false</constant> is returned.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-IsLowerTriangular"/>IsLowerTriangular</term>
         <listitem>
          <synopsis>IsLowerTriangular (M)</synopsis>
          <para>Является ли матрица нижнетреугольной, то есть все её элементы над диагональю равны нулю.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-IsMatrixInteger"/>IsMatrixInteger</term>
         <listitem>
          <synopsis>IsMatrixInteger (M)</synopsis>
          <para lang="en">Check if a matrix is a matrix of integers (non-complex).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-IsMatrixNonnegative"/>IsMatrixNonnegative</term>
         <listitem>
          <synopsis>IsMatrixNonnegative (M)</synopsis>
          <para lang="en">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.</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Positive_matrix">Wikipedia</ulink> for more information.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-IsMatrixPositive"/>IsMatrixPositive</term>
         <listitem>
          <synopsis lang="en">IsMatrixPositive (M)</synopsis>
	  <para lang="en">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.</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Positive_matrix">Wikipedia</ulink> for more information.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-IsMatrixRational"/>IsMatrixRational</term>
         <listitem>
          <synopsis>IsMatrixRational (M)</synopsis>
          <para>Проверяет, является ли матрица матрицей из рациональных (не комплексных) чисел.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-IsMatrixReal"/>IsMatrixReal</term>
         <listitem>
          <synopsis>IsMatrixReal (M)</synopsis>
          <para>Проверяет, является ли матрица матрицей из действительных (не комплексных) чисел.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-IsMatrixSquare"/>IsMatrixSquare</term>
         <listitem>
          <synopsis>IsMatrixSquare (M)</synopsis>
          <para>Проверяет, является ли матрица квадратной, то есть её ширина равна высоте.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-IsUpperTriangular"/>IsUpperTriangular</term>
         <listitem>
          <synopsis>IsUpperTriangular (M)</synopsis>
          <para lang="en">Is a matrix upper triangular?  That is, a matrix is upper triangular if all the entries below the diagonal are zero.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-IsValueOnly"/>IsValueOnly</term>
         <listitem>
          <synopsis>IsValueOnly (M)</synopsis>
          <para>Проверяет, состоит ли матрица только из чисел. Многие встроенные функции делают эту проверку. Значения могут быть любыми числами, включая комплексные.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-IsVector"/>IsVector</term>
         <listitem>
          <synopsis>IsVector (v)</synopsis>
          <para>Является ли аргумент горизонтальным или вертикальным вектором. Genius не делает различий между матрицей и вектором: вектор — это просто матрица 1 на <varname>n</varname> или <varname>n</varname> на 1.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-IsZero"/>IsZero</term>
         <listitem>
          <synopsis>IsZero (x)</synopsis>
          <para>Проверяет, состоит ли матрица из одних нулей. Также работает с числами, в этом случае эквивалентна выражению <userinput>x==0</userinput>. Если переменная <varname>x</varname> равна <constant>null</constant> (можно представить это, как матрицу 0 на 0 элементов), ошибка не генерируется и возвращается <constant>true</constant>, так как условие является бессмысленным.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-LowerTriangular"/>LowerTriangular</term>
         <listitem>
          <synopsis>LowerTriangular (M)</synopsis>
          <para>Возвращает копию матрицы <varname>M</varname>, в которой все элементы под диагональю заменены нулями.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-MakeDiagonal"/>MakeDiagonal</term>
         <listitem>
          <synopsis>MakeDiagonal (v,arg...)</synopsis>
          <para>Псевдоним: <function>diag</function></para>
	  <para>Создаёт диагональную матрицу из вектора. Значения для диагонали также могут быть переданы в виде аргументов функции. Поэтому <userinput>MakeDiagonal([1,2,3])</userinput> — то же самое, что и <userinput>MakeDiagonal(1,2,3)</userinput>.</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Diagonal_matrix">Wikipedia</ulink> or
	    <ulink url="http://planetmath.org/DiagonalMatrix">Planetmath</ulink> for more information.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-MakeVector"/>MakeVector</term>
         <listitem>
          <synopsis lang="en">MakeVector (A)</synopsis>
          <para lang="en">Alias: <function>MakeColumnVector</function></para>
          <para lang="en">Make column vector out of matrix by putting columns above
		  each other.  Returns <constant>null</constant> when given <constant>null</constant>.
		  Can be used to ensure a vector is a column vector.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-MakeRowVector"/>MakeRowVector</term>
         <listitem>
          <synopsis lang="en">MakeRowVector (A)</synopsis>
	  <para lang="en">Make row vector out of matrix by putting rows one after another.
		  Returns <constant>null</constant> when given <constant>null</constant>.
	          Can be used to ensure a vector is a row vector.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-MatrixProduct"/>MatrixProduct</term>
         <listitem>
          <synopsis>MatrixProduct (A)</synopsis>
          <para>Вычисляет произведение всех элементов матрицы или вектора. То есть, умножает друг на друга все элементы и возвращает число, являющееся их произведением.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-MatrixSum"/>MatrixSum</term>
         <listitem>
          <synopsis>MatrixSum (A)</synopsis>
          <para>Вычисляет сумму всех элементов матрицы или вектора. То есть, складывает все элементы и возвращает число, являющееся их суммой.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-MatrixSumSquares"/>MatrixSumSquares</term>
         <listitem>
          <synopsis>MatrixSumSquares (A)</synopsis>
          <para>Вычисляет сумму квадратов всех элементов матрицы или вектора.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-NonzeroColumns"/>NonzeroColumns</term>
         <listitem>
          <synopsis lang="en">NonzeroColumns (M)</synopsis>
          <para lang="en">Returns a row vector of the indices of nonzero columns in the matrix <varname>M</varname>.</para>
	  <para lang="en">Version 1.0.18 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-NonzeroElements"/>NonzeroElements</term>
         <listitem>
          <synopsis lang="en">NonzeroElements (v)</synopsis>
          <para lang="en">Returns a row vector of the indices of nonzero elements in the vector <varname>v</varname>.</para>
	  <para lang="en">Version 1.0.18 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-OuterProduct"/>OuterProduct</term>
         <listitem>
          <synopsis lang="en">OuterProduct (u,v)</synopsis>
          <para lang="en">Get the outer product of two vectors.  That is, suppose that
<varname>u</varname> and <varname>v</varname> are vertical vectors, then
the outer product is <userinput>v * u.'</userinput>.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-ReverseVector"/>ReverseVector</term>
         <listitem>
          <synopsis lang="en">ReverseVector (v)</synopsis>
	  <para lang="en">Reverse elements in a vector.  Return <constant>null</constant> if given <constant>null</constant></para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-RowSum"/>RowSum</term>
         <listitem>
          <synopsis>RowSum (m)</synopsis>
          <para>Вычисляет суммы элементов в каждой строке матрицы и возвращает вертикальный вектор с результатом.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-RowSumSquares"/>RowSumSquares</term>
         <listitem>
          <synopsis>RowSumSquares (m)</synopsis>
          <para>Вычисляет суммы квадратов элементов в каждой строке матрицы и возвращает вертикальный вектор с результатами.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-RowsOf"/>RowsOf</term>
         <listitem>
          <synopsis lang="en">RowsOf (M)</synopsis>
	  <para lang="en">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
<varname>M</varname>.  This function is useful if you wish to loop over the
rows of a matrix.  For example, as <userinput>for r in RowsOf(M) do
something(r)</userinput>.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-SetMatrixSize"/>SetMatrixSize</term>
         <listitem>
          <synopsis>SetMatrixSize (M,строки,столбцы)</synopsis>
          <para lang="en">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 <varname>rows</varname> or <varname>columns</varname> are zero
	  then <constant>null</constant> is returned.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-ShuffleVector"/>ShuffleVector</term>
         <listitem>
          <synopsis lang="en">ShuffleVector (v)</synopsis>
	  <para lang="en">Shuffle elements in a vector.  Return <constant>null</constant> if given <constant>null</constant>.</para>
	  <para lang="en">Version 1.0.13 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-SortVector"/>SortVector</term>
         <listitem>
          <synopsis lang="en">SortVector (v)</synopsis>
          <para lang="en">Sort vector elements in an increasing order.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-StripZeroColumns"/>StripZeroColumns</term>
         <listitem>
          <synopsis>StripZeroColumns (M)</synopsis>
          <para>Удаляет все состоящие только из нулей столбцы матрицы <varname>M</varname>.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-StripZeroRows"/>StripZeroRows</term>
         <listitem>
          <synopsis>StripZeroRows (M)</synopsis>
          <para>Удаляет все состоящие только из нулей строки матрицы <varname>M</varname>.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-Submatrix"/>Submatrix</term>
         <listitem>
          <synopsis lang="en">Submatrix (m,r,c)</synopsis>
          <para lang="en">Return column(s) and row(s) from a matrix.  This is
just equivalent to <userinput>m@(r,c)</userinput>.  <varname>r</varname>
and <varname>c</varname> should be vectors of rows and columns (or single numbers if only one row or column is needed).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-SwapRows"/>SwapRows</term>
         <listitem>
          <synopsis>SwapRows (m,строка1,строка2)</synopsis>
          <para>Меняет местами две строки матрицы.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-UpperTriangular"/>UpperTriangular</term>
         <listitem>
          <synopsis>UpperTriangular (M)</synopsis>
          <para>Возвращает копию матрицы <varname>M</varname>, в которой все элементы под диагональю заменены нулями.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-columns"/>columns</term>
         <listitem>
          <synopsis>columns (M)</synopsis>
          <para>Возвращает число столбцов в матрице.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-elements"/>elements</term>
         <listitem>
          <synopsis>elements (M)</synopsis>
          <para>Возвращает общее число элементов в матрице. Это число столбцов, умноженное на число строк.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-ones"/>ones</term>
         <listitem>
          <synopsis>ones (строки,столбцы...)</synopsis>
	  <para>Создаёт матрицу, состоящую только из единиц (или строчный вектор, если задан только один аргумент). Возвращает <constant>null</constant>, если задано число строк или столбцов, равное нулю.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-rows"/>rows</term>
         <listitem>
          <synopsis>rows (M)</synopsis>
          <para>Возвращает число строк в матрице.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-zeros"/>zeros</term>
         <listitem>
          <synopsis>zeros (строки,столбцы...)</synopsis>
	  <para>Создаёт матрицу, состоящую только из единиц (или строчный вектор, если задан только один аргумент). Возвращает <constant>null</constant>, если задано число строк или столбцов, равное нулю.</para>
         </listitem>
        </varlistentry>

      </variablelist>
    </sect1>

    <sect1 id="genius-gel-function-list-linear-algebra">
      <title>Линейная алгебра</title>
      <variablelist>
        <varlistentry>
         <term lang="en"><anchor id="gel-function-AuxiliaryUnitMatrix"/>AuxiliaryUnitMatrix</term>
         <listitem>
          <synopsis lang="en">AuxiliaryUnitMatrix (n)</synopsis>
          <para lang="en">Get the auxiliary unit matrix of size <varname>n</varname>.  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.</para>
          <para lang="en">
	    See
	    <ulink url="http://planetmath.org/JordanCanonicalFormTheorem">Planetmath</ulink> or
	    <ulink url="http://mathworld.wolfram.com/JordanBlock.html">Mathworld</ulink> for more information on Jordan Canonical Form.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-BilinearForm"/>BilinearForm</term>
         <listitem>
          <synopsis lang="en">BilinearForm (v,A,w)</synopsis>
          <para lang="en">Evaluate (v,w) with respect to the bilinear form given by the matrix A.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-BilinearFormFunction"/>BilinearFormFunction</term>
         <listitem>
          <synopsis lang="en">BilinearFormFunction (A)</synopsis>
          <para lang="en">Return a function that evaluates two vectors with respect to the bilinear form given by A.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-CharacteristicPolynomial"/>CharacteristicPolynomial</term>
         <listitem>
          <synopsis lang="en">CharacteristicPolynomial (M)</synopsis>
          <para lang="en">Aliases: <function>CharPoly</function></para>
	  <para lang="en">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 <userinput>det(M-xI)</userinput>.  The roots of this
polynomial are the eigenvalues of <varname>M</varname>.
See also <link linkend="gel-function-CharacteristicPolynomialFunction">CharacteristicPolynomialFunction</link>.
</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Characteristic_polynomial">Wikipedia</ulink> or
	    <ulink url="http://planetmath.org/CharacteristicEquation">Planetmath</ulink> for more information.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-CharacteristicPolynomialFunction"/>CharacteristicPolynomialFunction</term>
         <listitem>
          <synopsis lang="en">CharacteristicPolynomialFunction (M)</synopsis>
	  <para lang="en">Get the characteristic polynomial as a function.  This is
the polynomial defined by <userinput>det(M-xI)</userinput>.  The roots of this
polynomial are the eigenvalues of <varname>M</varname>.
See also <link linkend="gel-function-CharacteristicPolynomial">CharacteristicPolynomial</link>.
</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Characteristic_polynomial">Wikipedia</ulink> or
	    <ulink url="http://planetmath.org/CharacteristicEquation">Planetmath</ulink> for more information.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-ColumnSpace"/>ColumnSpace</term>
         <listitem>
          <synopsis lang="en">ColumnSpace (M)</synopsis>
	  <para lang="en">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
<varname>M</varname>.  That is the space spanned by the columns of
<varname>M</varname>.</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Row_and_column_spaces">Wikipedia</ulink> for more information.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-CommutationMatrix"/>CommutationMatrix</term>
         <listitem>
          <synopsis lang="en">CommutationMatrix (m, n)</synopsis>
	  <para lang="en">Return the commutation matrix <userinput>K(m,n)</userinput>, which is the unique <userinput>m*n</userinput> by
		  <userinput>m*n</userinput> matrix such that <userinput>K(m,n) * MakeVector(A) = MakeVector(A.')</userinput> for all <varname>m</varname> by <varname>n</varname>
		  matrices <varname>A</varname>.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-CompanionMatrix"/>CompanionMatrix</term>
         <listitem>
          <synopsis lang="en">CompanionMatrix (p)</synopsis>
          <para lang="en">Companion matrix of a polynomial (as vector).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-ConjugateTranspose"/>ConjugateTranspose</term>
         <listitem>
          <synopsis lang="en">ConjugateTranspose (M)</synopsis>
          <para lang="en">Conjugate transpose of a matrix (adjoint).  This is the
	  same as the <userinput>'</userinput> operator.</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Conjugate_transpose">Wikipedia</ulink> or
	    <ulink url="http://planetmath.org/ConjugateTranspose">Planetmath</ulink> for more information.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-Convolution"/>Convolution</term>
         <listitem>
          <synopsis lang="en">Convolution (a,b)</synopsis>
          <para lang="en">Aliases: <function>convol</function></para>
          <para lang="en">Calculate convolution of two horizontal vectors.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-ConvolutionVector"/>ConvolutionVector</term>
         <listitem>
          <synopsis lang="en">ConvolutionVector (a,b)</synopsis>
          <para lang="en">Calculate convolution of two horizontal vectors.  Return
result as a vector and not added together.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-CrossProduct"/>CrossProduct</term>
         <listitem>
          <synopsis lang="en">CrossProduct (v,w)</synopsis>
	  <para lang="en">CrossProduct of two vectors in R<superscript>3</superscript> as
		  a column vector.</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Cross_product">Wikipedia</ulink> for more information.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-DeterminantalDivisorsInteger"/>DeterminantalDivisorsInteger</term>
         <listitem>
          <synopsis lang="en">DeterminantalDivisorsInteger (M)</synopsis>
          <para lang="en">Get the determinantal divisors of an integer matrix.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-DirectSum"/>DirectSum</term>
         <listitem>
          <synopsis lang="en">DirectSum (M,N...)</synopsis>
          <para lang="en">Direct sum of matrices.</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Matrix_addition#directsum">Wikipedia</ulink> for more information.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-DirectSumMatrixVector"/>DirectSumMatrixVector</term>
         <listitem>
          <synopsis lang="en">DirectSumMatrixVector (v)</synopsis>
          <para lang="en">Direct sum of a vector of matrices.</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Matrix_addition#directsum">Wikipedia</ulink> for more information.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-Eigenvalues"/>Eigenvalues</term>
         <listitem>
          <synopsis lang="en">Eigenvalues (M)</synopsis>
          <para lang="en">Aliases: <function>eig</function></para>
          <para lang="en">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).
	  </para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Eigenvalue">Wikipedia</ulink>,
	    <ulink url="http://planetmath.org/Eigenvalue">Planetmath</ulink>, or
	    <ulink url="http://mathworld.wolfram.com/Eigenvalue.html">Mathworld</ulink> for more information.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-Eigenvectors"/>Eigenvectors</term>
         <listitem>
          <synopsis lang="en">Eigenvectors (M)</synopsis>
          <synopsis lang="en">Eigenvectors (M, &amp;eigenvalues)</synopsis>
          <synopsis lang="en">Eigenvectors (M, &amp;eigenvalues, &amp;multiplicities)</synopsis>
	  <para lang="en">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.
	  </para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Eigenvector">Wikipedia</ulink>,
	    <ulink url="http://planetmath.org/Eigenvector">Planetmath</ulink>, or
	    <ulink url="http://mathworld.wolfram.com/Eigenvector.html">Mathworld</ulink> for more information.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-GramSchmidt"/>GramSchmidt</term>
         <listitem>
          <synopsis lang="en">GramSchmidt (v,B...)</synopsis>
	  <para lang="en">Apply the Gram-Schmidt process (to the columns) with respect to
inner product given by <varname>B</varname>.  If <varname>B</varname> is not
given then the standard Hermitian product is used.  <varname>B</varname> 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
<varname>B</varname>.</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Gram%E2%80%93Schmidt_process">Wikipedia</ulink> or
	    <ulink url="http://planetmath.org/GramSchmidtOrthogonalization">Planetmath</ulink> for more information.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-HankelMatrix"/>HankelMatrix</term>
         <listitem>
          <synopsis lang="en">HankelMatrix (c,r)</synopsis>
	  <para lang="en">Hankel matrix, a matrix whose skew-diagonals are constant.  <varname>c</varname> is the first row and <varname>r</varname> is the
		  last column.  It is assumed that both arguments are vectors and the last element of <varname>c</varname> is the same
		  as the first element of <varname>r</varname>.</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Hankel_matrix">Wikipedia</ulink> for more information.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-HilbertMatrix"/>HilbertMatrix</term>
         <listitem>
          <synopsis lang="en">HilbertMatrix (n)</synopsis>
          <para lang="en">Hilbert matrix of order <varname>n</varname>.</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Hilbert_matrix">Wikipedia</ulink> or
	    <ulink url="http://planetmath.org/HilbertMatrix">Planetmath</ulink> for more information.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-Image"/>Image</term>
         <listitem>
          <synopsis lang="en">Image (T)</synopsis>
          <para lang="en">Get the image (columnspace) of a linear transform.</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Row_and_column_spaces">Wikipedia</ulink> for more information.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-InfNorm"/>InfNorm</term>
         <listitem>
          <synopsis lang="en">InfNorm (v)</synopsis>
          <para lang="en">Get the Inf Norm of a vector, sometimes called the sup norm or the max norm.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-InvariantFactorsInteger"/>InvariantFactorsInteger</term>
         <listitem>
          <synopsis lang="en">InvariantFactorsInteger (M)</synopsis>
          <para lang="en">Get the invariant factors of a square integer matrix.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-InverseHilbertMatrix"/>InverseHilbertMatrix</term>
         <listitem>
          <synopsis lang="en">InverseHilbertMatrix (n)</synopsis>
          <para lang="en">Inverse Hilbert matrix of order <varname>n</varname>.</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Hilbert_matrix">Wikipedia</ulink> or
	    <ulink url="http://planetmath.org/HilbertMatrix">Planetmath</ulink> for more information.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-IsHermitian"/>IsHermitian</term>
         <listitem>
          <synopsis lang="en">IsHermitian (M)</synopsis>
          <para lang="en">Is a matrix Hermitian.  That is, is it equal to its conjugate transpose.</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Hermitian_matrix">Wikipedia</ulink> or
	    <ulink url="http://planetmath.org/HermitianMatrix">Planetmath</ulink> for more information.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-IsInSubspace"/>IsInSubspace</term>
         <listitem>
          <synopsis lang="en">IsInSubspace (v,W)</synopsis>
          <para lang="en">Test if a vector is in a subspace.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-IsInvertible"/>IsInvertible</term>
         <listitem>
          <synopsis lang="en">IsInvertible (n)</synopsis>
          <para lang="en">Is a matrix (or number) invertible (Integer matrix is invertible if and only if it is invertible over the integers).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-IsInvertibleField"/>IsInvertibleField</term>
         <listitem>
          <synopsis lang="en">IsInvertibleField (n)</synopsis>
          <para lang="en">Is a matrix (or number) invertible over a field.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-IsNormal"/>IsNormal</term>
         <listitem>
          <synopsis lang="en">IsNormal (M)</synopsis>
          <para lang="en">Is <varname>M</varname> a normal matrix.  That is,
	  does <userinput>M*M' == M'*M</userinput>.</para>
          <para lang="en">
	    See
	    <ulink url="http://planetmath.org/NormalMatrix">Planetmath</ulink> or
	    <ulink url="http://mathworld.wolfram.com/NormalMatrix.html">Mathworld</ulink> for more information.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-IsPositiveDefinite"/>IsPositiveDefinite</term>
         <listitem>
          <synopsis lang="en">IsPositiveDefinite (M)</synopsis>
          <para lang="en">Is <varname>M</varname> a Hermitian positive definite matrix.  That is if
<userinput>HermitianProduct(M*v,v)</userinput> is always strictly positive for
any vector <varname>v</varname>.
<varname>M</varname> 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 <link linkend="gel-function-HermitianProduct">HermitianProduct</link>)</para>
	  <para lang="en">
	    Note that some authors (for example Mathworld) do not require that
	    <varname>M</varname> 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 <varname>M</varname> as follows:
	    <userinput>IsPositiveDefinite(M+M')</userinput>.
	  </para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Positive-definite_matrix">Wikipedia</ulink>,
	    <ulink url="http://planetmath.org/PositiveDefinite">Planetmath</ulink>, or
	    <ulink url="http://mathworld.wolfram.com/PositiveDefiniteMatrix.html">Mathworld</ulink> for more information.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-IsPositiveSemidefinite"/>IsPositiveSemidefinite</term>
         <listitem>
          <synopsis lang="en">IsPositiveSemidefinite (M)</synopsis>
          <para lang="en">Is <varname>M</varname> a Hermitian positive semidefinite matrix.  That is if
<userinput>HermitianProduct(M*v,v)</userinput> is always non-negative for
any vector <varname>v</varname>.
<varname>M</varname> 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 <link linkend="gel-function-HermitianProduct">HermitianProduct</link>)</para>
	  <para lang="en">
	    Note that some authors do not require that
	    <varname>M</varname> 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 <varname>M</varname> as follows:
	    <userinput>IsPositiveSemidefinite(M+M')</userinput>.
	  </para>
          <para lang="en">
	    See
	    <ulink url="http://planetmath.org/PositiveSemidefinite">Planetmath</ulink> or
	    <ulink url="http://mathworld.wolfram.com/PositiveSemidefiniteMatrix.html">Mathworld</ulink> for more information.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-IsSkewHermitian"/>IsSkewHermitian</term>
         <listitem>
          <synopsis lang="en">IsSkewHermitian (M)</synopsis>
          <para lang="en">Is a matrix skew-Hermitian.  That is, is the conjugate transpose equal to negative of the matrix.</para>
          <para lang="en">
	    See
	    <ulink url="http://planetmath.org/SkewHermitianMatrix">Planetmath</ulink> for more information.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-IsUnitary"/>IsUnitary</term>
         <listitem>
          <synopsis lang="en">IsUnitary (M)</synopsis>
          <para lang="en">Is a matrix unitary?  That is, does
	  <userinput>M'*M</userinput> and <userinput>M*M'</userinput>
	  equal the identity.</para>
          <para lang="en">
	    See
	    <ulink url="http://planetmath.org/UnitaryTransformation">Planetmath</ulink> or
	    <ulink url="http://mathworld.wolfram.com/UnitaryMatrix.html">Mathworld</ulink> for more information.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-JordanBlock"/>JordanBlock</term>
         <listitem>
          <synopsis lang="en">JordanBlock (n,lambda)</synopsis>
          <para lang="en">Aliases: <function>J</function></para>
          <para lang="en">Get the Jordan block corresponding to the eigenvalue
	  <varname>lambda</varname> with multiplicity <varname>n</varname>.
	  </para>
          <para lang="en">
	    See
	    <ulink url="http://planetmath.org/JordanCanonicalFormTheorem">Planetmath</ulink> or
	    <ulink url="http://mathworld.wolfram.com/JordanBlock.html">Mathworld</ulink> for more information.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-Kernel"/>Kernel</term>
         <listitem>
          <synopsis lang="en">Kernel (T)</synopsis>
          <para lang="en">Get the kernel (nullspace) of a linear transform.</para>
	  <para lang="en">
	  (See <link linkend="gel-function-NullSpace">NullSpace</link>)
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-KroneckerProduct"/>KroneckerProduct</term>
         <listitem>
          <synopsis lang="en">KroneckerProduct (M, N)</synopsis>
          <para lang="en">Aliases: <function>TensorProduct</function></para>
	  <para lang="en">
		  Compute the Kronecker product (tensor product in standard basis)
		  of two matrices.
	  </para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Kronecker_product">Wikipedia</ulink>, 
	    <ulink url="http://planetmath.org/KroneckerProduct">Planetmath</ulink> or
	    <ulink url="http://mathworld.wolfram.com/KroneckerProduct.html">Mathworld</ulink> for more information.
          </para>
	  <para lang="en">Version 1.0.18 onwards.</para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term lang="en"><anchor id="gel-function-LUDecomposition"/>LUDecomposition</term>
         <listitem>
          <synopsis lang="en">LUDecomposition (A, L, U)</synopsis>
          <para lang="en">
		  Get the LU decomposition of <varname>A</varname>, that is
		  find a lower triangular matrix and upper triangular
		  matrix whose product is <varname>A</varname>.
	    Store the result in the <varname>L</varname> and
	    <varname>U</varname>, which should be references.  It returns <constant>true</constant>
	    if successful.
	    For example suppose that A is a square matrix, then after running:
	    <screen lang="en"><prompt>genius&gt;</prompt> <userinput>LUDecomposition(A,&amp;L,&amp;U)</userinput>
</screen>
	    You will have the lower matrix stored in a variable called
	    <varname>L</varname> and the upper matrix in a variable called
	    <varname>U</varname>.
	  </para>
	  <para lang="en">
	    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. 
	  </para>
	  <para lang="en">
	    Not all matrices have LU decompositions, for example
	    <userinput>[0,1;1,0]</userinput> does not and this function returns
	    <constant>false</constant> in this case and sets <varname>L</varname>
	    and <varname>U</varname> to <constant>null</constant>.
	  </para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/LU_decomposition">Wikipedia</ulink>,
	    <ulink url="http://planetmath.org/LUDecomposition">Planetmath</ulink> or
	    <ulink url="http://mathworld.wolfram.com/LUDecomposition.html">Mathworld</ulink> for more information.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-Minor"/>Minor</term>
         <listitem>
          <synopsis lang="en">Minor (M,i,j)</synopsis>
          <para lang="en">Get the <varname>i</varname>-<varname>j</varname> minor of a matrix.</para>
          <para lang="en">
	    See
	    <ulink url="http://planetmath.org/Minor">Planetmath</ulink> for more information.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-NonPivotColumns"/>NonPivotColumns</term>
         <listitem>
          <synopsis lang="en">NonPivotColumns (M)</synopsis>
          <para lang="en">Return the columns that are not the pivot columns of a matrix.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-Norm"/>Norm</term>
         <listitem>
          <synopsis lang="en">Norm (v,p...)</synopsis>
          <para lang="en">Aliases: <function>norm</function></para>
          <para lang="en">Get the p Norm (or 2 Norm if no p is supplied) of a vector.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-NullSpace"/>NullSpace</term>
         <listitem>
          <synopsis lang="en">NullSpace (T)</synopsis>
          <para lang="en">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
	  <varname>T</varname>.</para>
          <para lang="en">
	    See
	    <ulink url="http://planetmath.org/Nullspace">Planetmath</ulink> for more information.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-Nullity"/>Nullity</term>
         <listitem>
          <synopsis lang="en">Nullity (M)</synopsis>
          <para lang="en">Aliases: <function>nullity</function></para>
          <para lang="en">Get the nullity of a matrix.  That is, return the dimension of
the nullspace; the dimension of the kernel of <varname>M</varname>.</para>
          <para lang="en">
	    See
	    <ulink url="http://planetmath.org/Nullity">Planetmath</ulink> for more information.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-OrthogonalComplement"/>OrthogonalComplement</term>
         <listitem>
          <synopsis lang="en">OrthogonalComplement (M)</synopsis>
          <para lang="en">Get the orthogonal complement of the columnspace.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-PivotColumns"/>PivotColumns</term>
         <listitem>
          <synopsis lang="en">PivotColumns (M)</synopsis>
          <para lang="en">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.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-Projection"/>Projection</term>
         <listitem>
          <synopsis lang="en">Projection (v,W,B...)</synopsis>
	  <para lang="en">Projection of vector <varname>v</varname> onto subspace
<varname>W</varname> with respect to inner product given by
<varname>B</varname>.  If <varname>B</varname> is not given then the standard
Hermitian product is used.  <varname>B</varname> can either be a sesquilinear
function of two arguments or it can be a matrix giving a sesquilinear form.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-QRDecomposition"/>QRDecomposition</term>
         <listitem>
          <synopsis lang="en">QRDecomposition (A, Q)</synopsis>
          <para lang="en">
	    Get the QR decomposition of a square matrix <varname>A</varname>,
	    returns the upper triangular matrix <varname>R</varname>
	    and sets <varname>Q</varname> to the orthogonal (unitary) matrix.
	    <varname>Q</varname> should be a reference or <constant>null</constant> if you don't
	    want any return.
	    For example:
	    <screen lang="en"><prompt>genius&gt;</prompt> <userinput>R = QRDecomposition(A,&amp;Q)</userinput>
</screen>
	    You will have the upper triangular matrix stored in
	    a variable called
	    <varname>R</varname> and the orthogonal (unitary) matrix stored in
	    <varname>Q</varname>.
	  </para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/QR_decomposition">Wikipedia</ulink> or
	    <ulink url="http://planetmath.org/QRDecomposition">Planetmath</ulink> or
	    <ulink url="http://mathworld.wolfram.com/QRDecomposition.html">Mathworld</ulink> for more information.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-RayleighQuotient"/>RayleighQuotient</term>
         <listitem>
          <synopsis lang="en">RayleighQuotient (A,x)</synopsis>
          <para lang="en">Return the Rayleigh quotient (also called the Rayleigh-Ritz quotient or ratio) of a matrix and a vector.</para>
          <para lang="en">
	    See
	    <ulink url="http://planetmath.org/RayleighQuotient">Planetmath</ulink> for more information.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-RayleighQuotientIteration"/>RayleighQuotientIteration</term>
         <listitem>
          <synopsis lang="en">RayleighQuotientIteration (A,x,epsilon,maxiter,vecref)</synopsis>
          <para lang="en">Find eigenvalues of <varname>A</varname> using the Rayleigh
	        quotient iteration method.  <varname>x</varname> 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
		<varname>maxiter</varname> iterations and return <constant>null</constant>
		if we cannot get within an error of <varname>epsilon</varname>.
		<varname>vecref</varname> should either be <constant>null</constant> or a reference
		to a variable where the eigenvector should be stored.
		</para>
          <para lang="en">
	    See
	    <ulink url="http://planetmath.org/RayleighQuotient">Planetmath</ulink> for more information on Rayleigh quotient.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-Rank"/>Rank</term>
         <listitem>
          <synopsis>Rank (M)</synopsis>
          <para>Синонимы: <function>rank</function></para>
          <para>Возвращает ранг матрицы.</para>
          <para lang="en">
	    See
	    <ulink url="http://planetmath.org/SylvestersLaw">Planetmath</ulink> for more information.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-RosserMatrix"/>RosserMatrix</term>
         <listitem>
          <synopsis lang="en">RosserMatrix ()</synopsis>
          <para lang="en">Returns the Rosser matrix, which is a classic symmetric eigenvalue test problem.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-Rotation2D"/>Rotation2D</term>
         <listitem>
          <synopsis lang="en">Rotation2D (angle)</synopsis>
          <para lang="en">Aliases: <function>RotationMatrix</function></para>
          <para lang="en">Return the matrix corresponding to rotation around origin in R<superscript>2</superscript>.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-Rotation3DX"/>Rotation3DX</term>
         <listitem>
          <synopsis lang="en">Rotation3DX (angle)</synopsis>
          <para lang="en">Return the matrix corresponding to rotation around origin in R<superscript>3</superscript> about the x-axis.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-Rotation3DY"/>Rotation3DY</term>
         <listitem>
          <synopsis lang="en">Rotation3DY (angle)</synopsis>
          <para lang="en">Return the matrix corresponding to rotation around origin in R<superscript>3</superscript> about the y-axis.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-Rotation3DZ"/>Rotation3DZ</term>
         <listitem>
          <synopsis lang="en">Rotation3DZ (angle)</synopsis>
          <para lang="en">Return the matrix corresponding to rotation around origin in R<superscript>3</superscript> about the z-axis.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-RowSpace"/>RowSpace</term>
         <listitem>
          <synopsis lang="en">RowSpace (M)</synopsis>
          <para lang="en">Get a basis matrix for the rowspace of a matrix.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-SesquilinearForm"/>SesquilinearForm</term>
         <listitem>
          <synopsis lang="en">SesquilinearForm (v,A,w)</synopsis>
          <para lang="en">Evaluate (v,w) with respect to the sesquilinear form given by the matrix A.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-SesquilinearFormFunction"/>SesquilinearFormFunction</term>
         <listitem>
          <synopsis lang="en">SesquilinearFormFunction (A)</synopsis>
          <para lang="en">Return a function that evaluates two vectors with respect to the sesquilinear form given by A.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-SmithNormalFormField"/>SmithNormalFormField</term>
         <listitem>
          <synopsis lang="en">SmithNormalFormField (A)</synopsis>
          <para lang="en">Returns the Smith normal form of a matrix over fields (will end up with 1's on the diagonal).</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Smith_normal_form">Wikipedia</ulink> for more information.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-SmithNormalFormInteger"/>SmithNormalFormInteger</term>
         <listitem>
          <synopsis lang="en">SmithNormalFormInteger (M)</synopsis>
          <para lang="en">Return the Smith normal form for square integer matrices over integers.</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Smith_normal_form">Wikipedia</ulink> for more information.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-SolveLinearSystem"/>SolveLinearSystem</term>
         <listitem>
          <synopsis lang="en">SolveLinearSystem (M,V,args...)</synopsis>
	  <para lang="en">Solve linear system Mx=V, return solution V if there is a unique solution, <constant>null</constant> otherwise.  Extra two reference parameters can optionally be used to get the reduced M and V.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-ToeplitzMatrix"/>ToeplitzMatrix</term>
         <listitem>
          <synopsis lang="en">ToeplitzMatrix (c, r...)</synopsis>
	  <para lang="en">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).</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Toeplitz_matrix">Wikipedia</ulink> or
	    <ulink url="http://planetmath.org/ToeplitzMatrix">Planetmath</ulink> for more information.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-Trace"/>Trace</term>
         <listitem>
          <synopsis lang="en">Trace (M)</synopsis>
          <para lang="en">Aliases: <function>trace</function></para>
          <para lang="en">Calculate the trace of a matrix.  That is the sum of the diagonal elements.</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Trace_(linear_algebra)">Wikipedia</ulink> or
	    <ulink url="http://planetmath.org/Trace">Planetmath</ulink> for more information.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-Transpose"/>Transpose</term>
         <listitem>
          <synopsis>Transpose (M)</synopsis>
          <para>Транспозиция матрицы. То же самое, что оператор <userinput>.'</userinput>.</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Transpose">Wikipedia</ulink> or
	    <ulink url="http://planetmath.org/Transpose">Planetmath</ulink> for more information.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-VandermondeMatrix"/>VandermondeMatrix</term>
         <listitem>
          <synopsis lang="en">VandermondeMatrix (v)</synopsis>
          <para lang="en">Aliases: <function>vander</function></para>
          <para lang="en">Return the Vandermonde matrix.</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Vandermonde_matrix">Wikipedia</ulink> for more information.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-VectorAngle"/>VectorAngle</term>
         <listitem>
          <synopsis lang="en">VectorAngle (v,w,B...)</synopsis>
          <para lang="en">The angle of two vectors with respect to inner product given by
<varname>B</varname>.  If <varname>B</varname> is not given then the standard
Hermitian product is used.  <varname>B</varname> can either be a sesquilinear
function of two arguments or it can be a matrix giving a sesquilinear form.
</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-VectorSpaceDirectSum"/>VectorSpaceDirectSum</term>
         <listitem>
          <synopsis lang="en">VectorSpaceDirectSum (M,N)</synopsis>
          <para lang="en">The direct sum of the vector spaces M and N.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-VectorSubspaceIntersection"/>VectorSubspaceIntersection</term>
         <listitem>
          <synopsis lang="en">VectorSubspaceIntersection (M,N)</synopsis>
          <para lang="en">Intersection of the subspaces given by M and N.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-VectorSubspaceSum"/>VectorSubspaceSum</term>
         <listitem>
          <synopsis lang="en">VectorSubspaceSum (M,N)</synopsis>
          <para lang="en">The sum of the vector spaces M and N, that is {w | w=m+n, m in M, n in N}.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-adj"/>adj</term>
         <listitem>
          <synopsis lang="en">adj (m)</synopsis>
          <para lang="en">Aliases: <function>Adjugate</function></para>
          <para lang="en">Get the classical adjoint (adjugate) of a matrix.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-cref"/>cref</term>
         <listitem>
          <synopsis lang="en">cref (M)</synopsis>
          <para lang="en">Aliases: <function>CREF</function> <function>ColumnReducedEchelonForm</function></para>
          <para lang="en">Compute the Column Reduced Echelon Form.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-det"/>det</term>
         <listitem>
          <synopsis lang="en">det (M)</synopsis>
          <para lang="en">Aliases: <function>Determinant</function></para>
          <para lang="en">Get the determinant of a matrix.</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Determinant">Wikipedia</ulink> or
	    <ulink url="http://planetmath.org/Determinant2">Planetmath</ulink> for more information.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-ref"/>ref</term>
         <listitem>
          <synopsis lang="en">ref (M)</synopsis>
          <para lang="en">Aliases: <function>REF</function> <function>RowEchelonForm</function></para>
	  <para lang="en">Get the row echelon form of a matrix.  That is, apply gaussian
elimination but not backaddition to <varname>M</varname>.  The pivot rows are
divided to make all pivots 1.</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Row_echelon_form">Wikipedia</ulink> or
	    <ulink url="http://planetmath.org/RowEchelonForm">Planetmath</ulink> for more information.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-rref"/>rref</term>
         <listitem>
          <synopsis lang="en">rref (M)</synopsis>
          <para lang="en">Aliases: <function>RREF</function> <function>ReducedRowEchelonForm</function></para>
          <para lang="en">Get the reduced row echelon form of a matrix.  That is, apply gaussian elimination together with backaddition to <varname>M</varname>.</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Reduced_row_echelon_form">Wikipedia</ulink> or
	    <ulink url="http://planetmath.org/ReducedRowEchelonForm">Planetmath</ulink> for more information.
          </para>
         </listitem>
        </varlistentry>

      </variablelist>
    </sect1>

    <sect1 id="genius-gel-function-list-combinatorics">
      <title>Комбинаторика</title>
      <variablelist>
        <varlistentry>
         <term lang="en"><anchor id="gel-function-Catalan"/>Catalan</term>
         <listitem>
          <synopsis>Catalan (n)</synopsis>
          <para>Возвращает <varname>n</varname>-ое число Каталана.</para>
          <para lang="en">
	    See
	    <ulink url="http://planetmath.org/CatalanNumbers">Planetmath</ulink> for more information.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-Combinations"/>Combinations</term>
         <listitem>
          <synopsis lang="en">Combinations (k,n)</synopsis>
          <para lang="en">Get all combinations of k numbers from 1 to n as a vector of vectors.
	  (See also <link linkend="gel-function-NextCombination">NextCombination</link>)
</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Combination">Wikipedia</ulink> for more information.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-DoubleFactorial"/>DoubleFactorial</term>
         <listitem>
          <synopsis>DoubleFactorial (n)</synopsis>
          <para>Двойной факториал: <userinput>n(n-2)(n-4)...</userinput></para>
          <para lang="en">
	    See
	    <ulink url="http://planetmath.org/DoubleFactorial">Planetmath</ulink> for more information.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-Factorial"/>Factorial</term>
         <listitem>
          <synopsis>Factorial (n)</synopsis>
          <para>Факториал: <userinput>n(n-1)(n-2)...</userinput></para>
          <para lang="en">
	    See
	    <ulink url="http://planetmath.org/Factorial">Planetmath</ulink> for more information.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-FallingFactorial"/>FallingFactorial</term>
         <listitem>
          <synopsis>FallingFactorial (n,k)</synopsis>
          <para>Убывающий факториал: <userinput>(n)_k = n(n-1)...(n-(k-1))</userinput></para>
          <para lang="en">
	    See
	    <ulink url="http://planetmath.org/FallingFactorial">Planetmath</ulink> for more information.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-Fibonacci"/>Fibonacci</term>
         <listitem>
          <synopsis>Fibonacci (x)</synopsis>
          <para>Синонимы: <function>fib</function></para>
          <para>Вычисляет <varname>n</varname>-ое число Фибоначчи. Это число, вычисляемое рекурсивно по формулам <userinput>Fibonacci(n) = Fibonacci(n-1) + Fibonacci(n-2)</userinput> и <userinput>Fibonacci(1) = Fibonacci(2) = 1</userinput>.</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Fibonacci_number">Wikipedia</ulink> or
	    <ulink url="http://planetmath.org/FibonacciSequence">Planetmath</ulink> or
	    <ulink url="http://mathworld.wolfram.com/FibonacciNumber.html">Mathworld</ulink> for more information.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-FrobeniusNumber"/>FrobeniusNumber</term>
         <listitem>
          <synopsis lang="en">FrobeniusNumber (v,arg...)</synopsis>
          <para lang="en">
	    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.
	  </para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Coin_problem">Wikipedia</ulink> or
	    <ulink url="http://mathworld.wolfram.com/FrobeniusNumber.html">Mathworld</ulink> for more information.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-GaloisMatrix"/>GaloisMatrix</term>
         <listitem>
          <synopsis lang="en">GaloisMatrix (combining_rule)</synopsis>
          <para lang="en">Galois matrix given a linear combining rule (a_1*x_1+...+a_n*x_n=x_(n+1)).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-GreedyAlgorithm"/>GreedyAlgorithm</term>
         <listitem>
          <synopsis lang="en">GreedyAlgorithm (n,v)</synopsis>
          <para lang="en">
	    Find the vector <varname>c</varname> of non-negative integers
	    such that taking the dot product with <varname>v</varname> is
	    equal to n.  If not possible returns <constant>null</constant>.  <varname>v</varname>
	    should be given sorted in increasing order and should consist
	    of non-negative integers.
	  </para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Greedy_algorithm">Wikipedia</ulink> or
	    <ulink url="http://mathworld.wolfram.com/GreedyAlgorithm.html">Mathworld</ulink> for more information.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-HarmonicNumber"/>HarmonicNumber</term>
         <listitem>
          <synopsis lang="en">HarmonicNumber (n,r)</synopsis>
          <para lang="en">Aliases: <function>HarmonicH</function></para>
	  <para lang="en">Harmonic Number, the <varname>n</varname>th harmonic number of order <varname>r</varname>.
	        That is, it is the sum of <userinput>1/k^r</userinput> for <varname>k</varname>
		from 1 to n.  Equivalent to <userinput>sum k = 1 to n do 1/k^r</userinput>.</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Harmonic_number">Wikipedia</ulink> for more information.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-Hofstadter"/>Hofstadter</term>
         <listitem>
          <synopsis lang="en">Hofstadter (n)</synopsis>
          <para lang="en">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)).</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Hofstadter_sequence">Wikipedia</ulink> for more information.
	    The sequence is <ulink url="https://oeis.org/A005185">A005185 in OEIS</ulink>.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-LinearRecursiveSequence"/>LinearRecursiveSequence</term>
         <listitem>
          <synopsis lang="en">LinearRecursiveSequence (seed_values,combining_rule,n)</synopsis>
          <para lang="en">Compute linear recursive sequence using Galois stepping.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-Multinomial"/>Multinomial</term>
         <listitem>
          <synopsis lang="en">Multinomial (v,arg...)</synopsis>
          <para lang="en">Calculate multinomial coefficients.  Takes a vector of
	    <varname>k</varname>
	    non-negative integers and computes the multinomial coefficient.
	    This corresponds to the coefficient in the homogeneous polynomial
	    in <varname>k</varname> variables with the corresponding powers.
	  </para>
	  <para lang="en">
	    The formula for <userinput>Multinomial(a,b,c)</userinput>
	    can be written as:
<programlisting lang="en">(a+b+c)! / (a!b!c!)
</programlisting>
	    In other words, if we would have only two elements, then
<userinput>Multinomial(a,b)</userinput> is the same thing as
<userinput>Binomial(a+b,a)</userinput> or
<userinput>Binomial(a+b,b)</userinput>.
	  </para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Multinomial_theorem">Wikipedia</ulink>,
	    <ulink url="http://planetmath.org/MultinomialTheorem">Planetmath</ulink>, or
	    <ulink url="http://mathworld.wolfram.com/MultinomialCoefficient.html">Mathworld</ulink> for more information.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-NextCombination"/>NextCombination</term>
         <listitem>
          <synopsis lang="en">NextCombination (v,n)</synopsis>
	  <para lang="en">Get combination that would come after v in call to
combinations, first combination should be <userinput>[1:k]</userinput>.  This
function is useful if you have many combinations to go through and you don't
want to waste memory to store them all.
	  </para>
	  <para lang="en">
	    For example with Combinations you would normally write a loop like:
          <screen lang="en"><userinput>for n in Combinations (4,6) do (
  SomeFunction (n)
);</userinput>
</screen>
	    But with NextCombination you would write something like:
          <screen lang="en"><userinput>n:=[1:4];
do (
  SomeFunction (n)
) while not IsNull(n:=NextCombination(n,6));</userinput>
</screen>
	  See also <link linkend="gel-function-Combinations">Combinations</link>.
	  </para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Combination">Wikipedia</ulink> for more information.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-Pascal"/>Pascal</term>
         <listitem>
          <synopsis lang="en">Pascal (i)</synopsis>
          <para lang="en">Get the Pascal's triangle as a matrix.  This will return
	  an <varname>i</varname>+1 by <varname>i</varname>+1 lower diagonal
	  matrix that is the Pascal's triangle after <varname>i</varname>
	  iterations.</para>
          <para lang="en">
	    See
	    <ulink url="http://planetmath.org/PascalsTriangle">Planetmath</ulink> for more information.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-Permutations"/>Permutations</term>
         <listitem>
          <synopsis lang="en">Permutations (k,n)</synopsis>
          <para lang="en">Get all permutations of <varname>k</varname> numbers from 1 to <varname>n</varname> as a vector of vectors.</para>
          <para lang="en">
	    See
	    <ulink url="http://mathworld.wolfram.com/Permutation.html">Mathworld</ulink> or
	    <ulink url="https://en.wikipedia.org/wiki/Permutation">Wikipedia</ulink> for more information.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-RisingFactorial"/>RisingFactorial</term>
         <listitem>
          <synopsis lang="en">RisingFactorial (n,k)</synopsis>
          <para lang="en">Aliases: <function>Pochhammer</function></para>
          <para lang="en">(Pochhammer) Rising factorial: (n)_k = n(n+1)...(n+(k-1)).</para>
          <para lang="en">
	    See
	    <ulink url="http://planetmath.org/RisingFactorial">Planetmath</ulink> for more information.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-StirlingNumberFirst"/>StirlingNumberFirst</term>
         <listitem>
          <synopsis lang="en">StirlingNumberFirst (n,m)</synopsis>
          <para lang="en">Aliases: <function>StirlingS1</function></para>
          <para lang="en">Stirling number of the first kind.</para>
          <para lang="en">
	    See
	    <ulink url="http://planetmath.org/StirlingNumbersOfTheFirstKind">Planetmath</ulink> or
	    <ulink url="http://mathworld.wolfram.com/StirlingNumberoftheFirstKind.html">Mathworld</ulink> for more information.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-StirlingNumberSecond"/>StirlingNumberSecond</term>
         <listitem>
          <synopsis lang="en">StirlingNumberSecond (n,m)</synopsis>
          <para lang="en">Aliases: <function>StirlingS2</function></para>
          <para lang="en">Stirling number of the second kind.</para>
          <para lang="en">
	    See
	    <ulink url="http://planetmath.org/StirlingNumbersSecondKind">Planetmath</ulink> or
	    <ulink url="http://mathworld.wolfram.com/StirlingNumberoftheSecondKind.html">Mathworld</ulink> for more information.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-Subfactorial"/>Subfactorial</term>
         <listitem>
          <synopsis lang="en">Subfactorial (n)</synopsis>
          <para lang="en">Subfactorial: n! times sum_{k=0}^n (-1)^k/k!.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-Triangular"/>Triangular</term>
         <listitem>
          <synopsis lang="en">Triangular (nth)</synopsis>
          <para lang="en">Calculate the <varname>n</varname>th triangular number.</para>
          <para lang="en">
	    See
	    <ulink url="http://planetmath.org/TriangularNumbers">Planetmath</ulink> for more information.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-nCr"/>nCr</term>
         <listitem>
          <synopsis lang="en">nCr (n,r)</synopsis>
          <para lang="en">Aliases: <function>Binomial</function></para>
          <para lang="en">Calculate combinations, that is, the binomial coefficient.
	        <varname>n</varname> can be any real number.</para>
          <para lang="en">
	    See
	    <ulink url="http://planetmath.org/Choose">Planetmath</ulink> for more information.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-nPr"/>nPr</term>
         <listitem>
          <synopsis lang="en">nPr (n,r)</synopsis>
          <para lang="en">Calculate the number of permutations of size
	   <varname>r</varname> of numbers from 1 to <varname>n</varname>.</para>
          <para lang="en">
	    See
	    <ulink url="http://mathworld.wolfram.com/Permutation.html">Mathworld</ulink> or
	    <ulink url="https://en.wikipedia.org/wiki/Permutation">Wikipedia</ulink> for more information.
	  </para>
         </listitem>
        </varlistentry>

      </variablelist>
    </sect1>

    <sect1 id="genius-gel-function-list-calculus">
      <title lang="en">Calculus</title>
      <variablelist>
        <varlistentry>
         <term lang="en"><anchor id="gel-function-CompositeSimpsonsRule"/>CompositeSimpsonsRule</term>
         <listitem>
          <synopsis lang="en">CompositeSimpsonsRule (f,a,b,n)</synopsis>
          <para lang="en">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.</para>
          <para lang="en">
	    See
	    <ulink url="http://planetmath.org/SimpsonsRule">Planetmath</ulink> for more information.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-CompositeSimpsonsRuleTolerance"/>CompositeSimpsonsRuleTolerance</term>
         <listitem>
          <synopsis lang="en">CompositeSimpsonsRuleTolerance (f,a,b,FourthDerivativeBound,Tolerance)</synopsis>
          <para lang="en">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.</para>
          <para lang="en">
	    See
	    <ulink url="http://planetmath.org/SimpsonsRule">Planetmath</ulink> for more information.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-Derivative"/>Derivative</term>
         <listitem>
          <synopsis lang="en">Derivative (f,x0)</synopsis>
          <para lang="en">Attempt to calculate derivative by trying first symbolically and then numerically.</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Derivative">Wikipedia</ulink> for more information.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-EvenPeriodicExtension"/>EvenPeriodicExtension</term>
         <listitem>
          <synopsis lang="en">EvenPeriodicExtension (f,L)</synopsis>
	  <para lang="en">Return a function that is the even periodic extension of
<function>f</function> with half period <varname>L</varname>.  That
is a function defined on the interval <userinput>[0,L]</userinput>
extended to be even on <userinput>[-L,L]</userinput> and then
extended to be periodic with period <userinput>2*L</userinput>.</para>
	  <para lang="en">
	    See also
	    <link linkend="gel-function-OddPeriodicExtension">OddPeriodicExtension</link>
	    and
	    <link linkend="gel-function-PeriodicExtension">PeriodicExtension</link>.
	  </para>
	  <para lang="en">Version 1.0.7 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-FourierSeriesFunction"/>FourierSeriesFunction</term>
         <listitem>
          <synopsis lang="en">FourierSeriesFunction (a,b,L)</synopsis>
	  <para lang="en">Return a function that is a Fourier series with the
coefficients given by the vectors <varname>a</varname> (sines) and
<varname>b</varname> (cosines).  Note that <userinput>a@(1)</userinput> is
the constant coefficient!  That is, <userinput>a@(n)</userinput> refers to
the term <userinput>cos(x*(n-1)*pi/L)</userinput>, while
<userinput>b@(n)</userinput> refers to the term
<userinput>sin(x*n*pi/L)</userinput>.  Either <varname>a</varname>
or <varname>b</varname> can be <constant>null</constant>.</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Fourier_series">Wikipedia</ulink> or
	    <ulink url="http://mathworld.wolfram.com/FourierSeries.html">Mathworld</ulink> for more information.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-InfiniteProduct"/>InfiniteProduct</term>
         <listitem>
          <synopsis lang="en">InfiniteProduct (func,start,inc)</synopsis>
          <para lang="en">Try to calculate an infinite product for a single parameter function.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-InfiniteProduct2"/>InfiniteProduct2</term>
         <listitem>
          <synopsis lang="en">InfiniteProduct2 (func,arg,start,inc)</synopsis>
          <para lang="en">Try to calculate an infinite product for a double parameter function with func(arg,n).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-InfiniteSum"/>InfiniteSum</term>
         <listitem>
          <synopsis lang="en">InfiniteSum (func,start,inc)</synopsis>
          <para lang="en">Try to calculate an infinite sum for a single parameter function.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-InfiniteSum2"/>InfiniteSum2</term>
         <listitem>
          <synopsis lang="en">InfiniteSum2 (func,arg,start,inc)</synopsis>
          <para lang="en">Try to calculate an infinite sum for a double parameter function with func(arg,n).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-IsContinuous"/>IsContinuous</term>
         <listitem>
          <synopsis lang="en">IsContinuous (f,x0)</synopsis>
          <para lang="en">Try and see if a real-valued function is continuous at x0 by calculating the limit there.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-IsDifferentiable"/>IsDifferentiable</term>
         <listitem>
          <synopsis lang="en">IsDifferentiable (f,x0)</synopsis>
          <para lang="en">Test for differentiability by approximating the left and right limits and comparing.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-LeftLimit"/>LeftLimit</term>
         <listitem>
          <synopsis lang="en">LeftLimit (f,x0)</synopsis>
          <para lang="en">Calculate the left limit of a real-valued function at x0.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-Limit"/>Limit</term>
         <listitem>
          <synopsis lang="en">Limit (f,x0)</synopsis>
          <para lang="en">Calculate the limit of a real-valued function at x0.  Tries to calculate both left and right limits.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-MidpointRule"/>MidpointRule</term>
         <listitem>
          <synopsis lang="en">MidpointRule (f,a,b,n)</synopsis>
          <para lang="en">Integration by midpoint rule.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-NumericalDerivative"/>NumericalDerivative</term>
         <listitem>
          <synopsis lang="en">NumericalDerivative (f,x0)</synopsis>
          <para lang="en">Aliases: <function>NDerivative</function></para>
          <para lang="en">Attempt to calculate numerical derivative.</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Derivative">Wikipedia</ulink> for more information.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-NumericalFourierSeriesCoefficients"/>NumericalFourierSeriesCoefficients</term>
         <listitem>
          <synopsis lang="en">NumericalFourierSeriesCoefficients (f,L,N)</synopsis>
	  <para lang="en">Return a vector of vectors <userinput>[a,b]</userinput>
where <varname>a</varname> are the cosine coefficients and
<varname>b</varname> are the sine coefficients of
the Fourier series of
<function>f</function> with half-period <varname>L</varname> (that is defined
on <userinput>[-L,L]</userinput> and extended periodically) with coefficients
up to <varname>N</varname>th harmonic computed numerically.  The coefficients are
computed by numerical integration using
<link linkend="gel-function-NumericalIntegral"><function>NumericalIntegral</function></link>.</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Fourier_series">Wikipedia</ulink> or
	    <ulink url="http://mathworld.wolfram.com/FourierSeries.html">Mathworld</ulink> for more information.
          </para>
	  <para lang="en">Version 1.0.7 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-NumericalFourierSeriesFunction"/>NumericalFourierSeriesFunction</term>
         <listitem>
          <synopsis lang="en">NumericalFourierSeriesFunction (f,L,N)</synopsis>
	  <para lang="en">Return a function that is the Fourier series of
<function>f</function> with half-period <varname>L</varname> (that is defined
on <userinput>[-L,L]</userinput> and extended periodically) with coefficients
up to <varname>N</varname>th harmonic computed numerically.  This is the
trigonometric real series composed of sines and cosines.  The coefficients are
computed by numerical integration using
<link linkend="gel-function-NumericalIntegral"><function>NumericalIntegral</function></link>.</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Fourier_series">Wikipedia</ulink> or
	    <ulink url="http://mathworld.wolfram.com/FourierSeries.html">Mathworld</ulink> for more information.
          </para>
	  <para lang="en">Version 1.0.7 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-NumericalFourierCosineSeriesCoefficients"/>NumericalFourierCosineSeriesCoefficients</term>
         <listitem>
          <synopsis lang="en">NumericalFourierCosineSeriesCoefficients (f,L,N)</synopsis>
	  <para lang="en">Return a vector of coefficients of 
the cosine Fourier series of
<function>f</function> with half-period <varname>L</varname>.  That is,
we take <function>f</function> defined on <userinput>[0,L]</userinput>
take the even periodic extension and compute the Fourier series, which
only has cosine terms.  The series is computed up to the 
<varname>N</varname>th harmonic.  The coefficients are
computed by numerical integration using
<link linkend="gel-function-NumericalIntegral"><function>NumericalIntegral</function></link>.
Note that <userinput>a@(1)</userinput> is
the constant coefficient!  That is, <userinput>a@(n)</userinput> refers to
the term <userinput>cos(x*(n-1)*pi/L)</userinput>.</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Fourier_series">Wikipedia</ulink> or
	    <ulink url="http://mathworld.wolfram.com/FourierCosineSeries.html">Mathworld</ulink> for more information.
          </para>
	  <para lang="en">Version 1.0.7 onwards.</para>
	  </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-NumericalFourierCosineSeriesFunction"/>NumericalFourierCosineSeriesFunction</term>
         <listitem>
          <synopsis lang="en">NumericalFourierCosineSeriesFunction (f,L,N)</synopsis>
	  <para lang="en">Return a function that is the cosine Fourier series of
<function>f</function> with half-period <varname>L</varname>.  That is,
we take <function>f</function> defined on <userinput>[0,L]</userinput>
take the even periodic extension and compute the Fourier series, which
only has cosine terms.  The series is computed up to the 
<varname>N</varname>th harmonic.  The coefficients are
computed by numerical integration using
<link linkend="gel-function-NumericalIntegral"><function>NumericalIntegral</function></link>.</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Fourier_series">Wikipedia</ulink> or
	    <ulink url="http://mathworld.wolfram.com/FourierCosineSeries.html">Mathworld</ulink> for more information.
          </para>
	  <para lang="en">Version 1.0.7 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-NumericalFourierSineSeriesCoefficients"/>NumericalFourierSineSeriesCoefficients</term>
         <listitem>
          <synopsis lang="en">NumericalFourierSineSeriesCoefficients (f,L,N)</synopsis>
	  <para lang="en">Return a vector of coefficients of 
the sine Fourier series of
<function>f</function> with half-period <varname>L</varname>.  That is,
we take <function>f</function> defined on <userinput>[0,L]</userinput>
take the odd periodic extension and compute the Fourier series, which
only has sine terms.  The series is computed up to the 
<varname>N</varname>th harmonic.  The coefficients are
computed by numerical integration using
<link linkend="gel-function-NumericalIntegral"><function>NumericalIntegral</function></link>.</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Fourier_series">Wikipedia</ulink> or
	    <ulink url="http://mathworld.wolfram.com/FourierSineSeries.html">Mathworld</ulink> for more information.
          </para>
	  <para lang="en">Version 1.0.7 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-NumericalFourierSineSeriesFunction"/>NumericalFourierSineSeriesFunction</term>
         <listitem>
          <synopsis lang="en">NumericalFourierSineSeriesFunction (f,L,N)</synopsis>
	  <para lang="en">Return a function that is the sine Fourier series of
<function>f</function> with half-period <varname>L</varname>.  That is,
we take <function>f</function> defined on <userinput>[0,L]</userinput>
take the odd periodic extension and compute the Fourier series, which
only has sine terms.  The series is computed up to the 
<varname>N</varname>th harmonic.  The coefficients are
computed by numerical integration using
<link linkend="gel-function-NumericalIntegral"><function>NumericalIntegral</function></link>.</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Fourier_series">Wikipedia</ulink> or
	    <ulink url="http://mathworld.wolfram.com/FourierSineSeries.html">Mathworld</ulink> for more information.
          </para>
	  <para lang="en">Version 1.0.7 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-NumericalIntegral"/>NumericalIntegral</term>
         <listitem>
          <synopsis lang="en">NumericalIntegral (f,a,b)</synopsis>
          <para lang="en">Integration by rule set in NumericalIntegralFunction of f from a to b using NumericalIntegralSteps steps.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-NumericalLeftDerivative"/>NumericalLeftDerivative</term>
         <listitem>
          <synopsis lang="en">NumericalLeftDerivative (f,x0)</synopsis>
          <para lang="en">Attempt to calculate numerical left derivative.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-NumericalLimitAtInfinity"/>NumericalLimitAtInfinity</term>
         <listitem>
          <synopsis lang="en">NumericalLimitAtInfinity (_f,step_fun,tolerance,successive_for_success,N)</synopsis>
          <para lang="en">Attempt to calculate the limit of f(step_fun(i)) as i goes from 1 to N.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-NumericalRightDerivative"/>NumericalRightDerivative</term>
         <listitem>
          <synopsis lang="en">NumericalRightDerivative (f,x0)</synopsis>
          <para lang="en">Attempt to calculate numerical right derivative.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-OddPeriodicExtension"/>OddPeriodicExtension</term>
         <listitem>
          <synopsis lang="en">OddPeriodicExtension (f,L)</synopsis>
	  <para lang="en">Return a function that is the odd periodic extension of
<function>f</function> with half period <varname>L</varname>.  That
is a function defined on the interval <userinput>[0,L]</userinput>
extended to be odd on <userinput>[-L,L]</userinput> and then
extended to be periodic with period <userinput>2*L</userinput>.</para>
	  <para lang="en">
	    See also
	    <link linkend="gel-function-EvenPeriodicExtension">EvenPeriodicExtension</link>
	    and
	    <link linkend="gel-function-PeriodicExtension">PeriodicExtension</link>.
	  </para>
	  <para lang="en">Version 1.0.7 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-OneSidedFivePointFormula"/>OneSidedFivePointFormula</term>
         <listitem>
          <synopsis lang="en">OneSidedFivePointFormula (f,x0,h)</synopsis>
          <para lang="en">Compute one-sided derivative using five point formula.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-OneSidedThreePointFormula"/>OneSidedThreePointFormula</term>
         <listitem>
          <synopsis lang="en">OneSidedThreePointFormula (f,x0,h)</synopsis>
          <para lang="en">Compute one-sided derivative using three-point formula.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-PeriodicExtension"/>PeriodicExtension</term>
         <listitem>
          <synopsis lang="en">PeriodicExtension (f,a,b)</synopsis>
	  <para lang="en">Return a function that is the periodic extension of
<function>f</function> defined on the interval <userinput>[a,b]</userinput>
and has period <userinput>b-a</userinput>.</para>
	  <para lang="en">
	    See also
	    <link linkend="gel-function-OddPeriodicExtension">OddPeriodicExtension</link>
	    and
	    <link linkend="gel-function-EvenPeriodicExtension">EvenPeriodicExtension</link>.
	  </para>
	  <para lang="en">Version 1.0.7 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-RightLimit"/>RightLimit</term>
         <listitem>
          <synopsis lang="en">RightLimit (f,x0)</synopsis>
          <para lang="en">Calculate the right limit of a real-valued function at x0.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-TwoSidedFivePointFormula"/>TwoSidedFivePointFormula</term>
         <listitem>
          <synopsis lang="en">TwoSidedFivePointFormula (f,x0,h)</synopsis>
          <para lang="en">Compute two-sided derivative using five-point formula.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-TwoSidedThreePointFormula"/>TwoSidedThreePointFormula</term>
         <listitem>
          <synopsis lang="en">TwoSidedThreePointFormula (f,x0,h)</synopsis>
          <para lang="en">Compute two-sided derivative using three-point formula.</para>
         </listitem>
        </varlistentry>

      </variablelist>
    </sect1>

    <sect1 id="genius-gel-function-list-functions">
      <title lang="en">Functions</title>
      <variablelist>
        <varlistentry>
         <term lang="en"><anchor id="gel-function-Argument"/>Argument</term>
         <listitem>
          <synopsis lang="en">Argument (z)</synopsis>
          <para lang="en">Aliases: <function>Arg</function> <function>arg</function></para>
          <para lang="en">argument (angle) of complex number.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-BesselJ0"/>BesselJ0</term>
         <listitem>
          <synopsis lang="en">BesselJ0 (x)</synopsis>
          <para lang="en">Bessel function of the first kind of order 0.  Only implemented for real numbers.</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Bessel_functions">Wikipedia</ulink> for more information.
	  </para>
	  <para lang="en">Version 1.0.16 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-BesselJ1"/>BesselJ1</term>
         <listitem>
          <synopsis lang="en">BesselJ1 (x)</synopsis>
          <para lang="en">Bessel function of the first kind of order 1.  Only implemented for real numbers.</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Bessel_functions">Wikipedia</ulink> for more information.
	  </para>
	  <para lang="en">Version 1.0.16 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-BesselJn"/>BesselJn</term>
         <listitem>
          <synopsis lang="en">BesselJn (n,x)</synopsis>
	  <para lang="en">Bessel function of the first kind of order <varname>n</varname>.  Only implemented for real numbers.</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Bessel_functions">Wikipedia</ulink> for more information.
	  </para>
	  <para lang="en">Version 1.0.16 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-BesselY0"/>BesselY0</term>
         <listitem>
          <synopsis lang="en">BesselY0 (x)</synopsis>
          <para lang="en">Bessel function of the second kind of order 0.  Only implemented for real numbers.</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Bessel_functions">Wikipedia</ulink> for more information.
	  </para>
	  <para lang="en">Version 1.0.16 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-BesselY1"/>BesselY1</term>
         <listitem>
          <synopsis lang="en">BesselY1 (x)</synopsis>
          <para lang="en">Bessel function of the second kind of order 1.  Only implemented for real numbers.</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Bessel_functions">Wikipedia</ulink> for more information.
	  </para>
	  <para lang="en">Version 1.0.16 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-BesselYn"/>BesselYn</term>
         <listitem>
          <synopsis lang="en">BesselYn (n,x)</synopsis>
	  <para lang="en">Bessel function of the second kind of order <varname>n</varname>.  Only implemented for real numbers.</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Bessel_functions">Wikipedia</ulink> for more information.
	  </para>
	  <para lang="en">Version 1.0.16 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-DirichletKernel"/>DirichletKernel</term>
         <listitem>
          <synopsis lang="en">DirichletKernel (n,t)</synopsis>
	  <para lang="en">Dirichlet kernel of order <varname>n</varname>.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-DiscreteDelta"/>DiscreteDelta</term>
         <listitem>
          <synopsis lang="en">DiscreteDelta (v)</synopsis>
          <para lang="en">Returns 1 if and only if all elements are zero.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-ErrorFunction"/>ErrorFunction</term>
         <listitem>
          <synopsis lang="en">ErrorFunction (x)</synopsis>
          <para lang="en">Aliases: <function>erf</function></para>
          <para lang="en">The error function, 2/sqrt(pi) * int_0^x e^(-t^2) dt.</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Error_function">Wikipedia</ulink> or
	    <ulink url="http://planetmath.org/ErrorFunction">Planetmath</ulink> for more information.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-FejerKernel"/>FejerKernel</term>
         <listitem>
          <synopsis lang="en">FejerKernel (n,t)</synopsis>
          <para lang="en">Fejer kernel of order <varname>n</varname> evaluated at
	        <varname>t</varname></para>
          <para lang="en">
	    See
	    <ulink url="http://planetmath.org/FejerKernel">Planetmath</ulink> for more information.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-GammaFunction"/>GammaFunction</term>
         <listitem>
          <synopsis lang="en">GammaFunction (x)</synopsis>
          <para lang="en">Aliases: <function>Gamma</function></para>
          <para lang="en">The Gamma function.  Currently only implemented for real values.</para>
          <para lang="en">
	    See
	    <ulink url="http://planetmath.org/GammaFunction">Planetmath</ulink> or
	    <ulink url="https://en.wikipedia.org/wiki/Gamma_function">Wikipedia</ulink> for more information.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-KroneckerDelta"/>KroneckerDelta</term>
         <listitem>
          <synopsis lang="en">KroneckerDelta (v)</synopsis>
          <para lang="en">Returns 1 if and only if all elements are equal.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-LambertW"/>LambertW</term>
         <listitem>
          <synopsis lang="en">LambertW (x)</synopsis>
	  <para lang="en">
		  The principal branch of Lambert W function computed for only
		  real values greater than or equal to <userinput>-1/e</userinput>.
		  That is, <function>LambertW</function> is the inverse of
		  the expression <userinput>x*e^x</userinput>.  Even for
		  real <varname>x</varname> this expression is not one to one and
		  therefore has two branches over <userinput>[-1/e,0)</userinput>.
		  See <link linkend="gel-function-LambertWm1"><function>LambertWm1</function></link> for the other real branch.
	  </para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Lambert_W_function">Wikipedia</ulink> for more information.
	  </para>
	  <para lang="en">Version 1.0.18 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-LambertWm1"/>LambertWm1</term>
         <listitem>
          <synopsis lang="en">LambertWm1 (x)</synopsis>
	  <para lang="en">
		  The minus-one branch of Lambert W function computed for only
		  real values greater than or equal to <userinput>-1/e</userinput>
		  and less than 0.
		  That is, <function>LambertWm1</function> is the second
		  branch of the inverse of <userinput>x*e^x</userinput>.
		  See <link linkend="gel-function-LambertW"><function>LambertW</function></link> for the principal branch.
	  </para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Lambert_W_function">Wikipedia</ulink> for more information.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-MinimizeFunction"/>MinimizeFunction</term>
         <listitem>
          <synopsis lang="en">MinimizeFunction (func,x,incr)</synopsis>
          <para lang="en">Find the first value where f(x)=0.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-MoebiusDiskMapping"/>MoebiusDiskMapping</term>
         <listitem>
          <synopsis lang="en">MoebiusDiskMapping (a,z)</synopsis>
          <para lang="en">Moebius mapping of the disk to itself mapping a to 0.</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/M%C3%B6bius_transformation">Wikipedia</ulink> or
	    <ulink url="http://planetmath.org/MobiusTransformation">Planetmath</ulink> for more information.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-MoebiusMapping"/>MoebiusMapping</term>
         <listitem>
          <synopsis lang="en">MoebiusMapping (z,z2,z3,z4)</synopsis>
          <para lang="en">Moebius mapping using the cross ratio taking z2,z3,z4 to 1,0, and infinity respectively.</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/M%C3%B6bius_transformation">Wikipedia</ulink> or
	    <ulink url="http://planetmath.org/MobiusTransformation">Planetmath</ulink> for more information.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-MoebiusMappingInftyToInfty"/>MoebiusMappingInftyToInfty</term>
         <listitem>
          <synopsis lang="en">MoebiusMappingInftyToInfty (z,z2,z3)</synopsis>
          <para lang="en">Moebius mapping using the cross ratio taking infinity to infinity and z2,z3 to 1 and 0 respectively.</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/M%C3%B6bius_transformation">Wikipedia</ulink> or
	    <ulink url="http://planetmath.org/MobiusTransformation">Planetmath</ulink> for more information.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-MoebiusMappingInftyToOne"/>MoebiusMappingInftyToOne</term>
         <listitem>
          <synopsis lang="en">MoebiusMappingInftyToOne (z,z3,z4)</synopsis>
          <para lang="en">Moebius mapping using the cross ratio taking infinity to 1 and z3,z4 to 0 and infinity respectively.</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/M%C3%B6bius_transformation">Wikipedia</ulink> or
	    <ulink url="http://planetmath.org/MobiusTransformation">Planetmath</ulink> for more information.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-MoebiusMappingInftyToZero"/>MoebiusMappingInftyToZero</term>
         <listitem>
          <synopsis lang="en">MoebiusMappingInftyToZero (z,z2,z4)</synopsis>
          <para lang="en">Moebius mapping using the cross ratio taking infinity to 0 and z2,z4 to 1 and infinity respectively.</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/M%C3%B6bius_transformation">Wikipedia</ulink> or
	    <ulink url="http://planetmath.org/MobiusTransformation">Planetmath</ulink> for more information.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-PoissonKernel"/>PoissonKernel</term>
         <listitem>
          <synopsis lang="en">PoissonKernel (r,sigma)</synopsis>
          <para lang="en">Poisson kernel on D(0,1) (not normalized to 1, that is integral of this is 2pi).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-PoissonKernelRadius"/>PoissonKernelRadius</term>
         <listitem>
          <synopsis lang="en">PoissonKernelRadius (r,sigma)</synopsis>
          <para lang="en">Poisson kernel on D(0,R) (not normalized to 1).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-RiemannZeta"/>RiemannZeta</term>
         <listitem>
          <synopsis lang="en">RiemannZeta (x)</synopsis>
          <para lang="en">Aliases: <function>zeta</function></para>
          <para lang="en">The Riemann zeta function.  Currently only implemented for real values.</para>
          <para lang="en">
	    See
	    <ulink url="http://planetmath.org/RiemannZetaFunction">Planetmath</ulink> or
	    <ulink url="https://en.wikipedia.org/wiki/Riemann_zeta_function">Wikipedia</ulink> for more information.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-UnitStep"/>UnitStep</term>
         <listitem>
          <synopsis lang="en">UnitStep (x)</synopsis>
          <para lang="en">The unit step function is 0 for x&lt;0, 1 otherwise.  This is the integral of the Dirac Delta function.  Also called the Heaviside function.</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Unit_step">Wikipedia</ulink> for more information.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-cis"/>cis</term>
         <listitem>
          <synopsis>cis (x)</synopsis>
          <para>Функция <function>cis</function>, то же самое, что <userinput>cos(x)+1i*sin(x)</userinput></para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-deg2rad"/>deg2rad</term>
         <listitem>
          <synopsis>deg2rad (x)</synopsis>
          <para>Преобразует градусы в радианы.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-rad2deg"/>rad2deg</term>
         <listitem>
          <synopsis>rad2deg (x)</synopsis>
          <para>Преобразует радианы в градусы.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-sinc"/>sinc</term>
         <listitem>
          <synopsis lang="en">sinc (x)</synopsis>
	  <para lang="en">Calculates the unnormalized sinc function, that is
		  <userinput>sin(x)/x</userinput>.
		  If you want the normalized function call <userinput>sinc(pi*x)</userinput>.</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Sinc">Wikipedia</ulink> for more information.
	  </para>
	  <para lang="en">Version 1.0.16 onwards.</para>
         </listitem>
        </varlistentry>

      </variablelist>
    </sect1>

    <sect1 id="genius-gel-function-list-equation-solving">
      <title>Решение уравнений</title>
      <variablelist>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-CubicFormula"/>CubicFormula</term>
         <listitem>
          <synopsis lang="en">CubicFormula (p)</synopsis>
          <para lang="en">
	    Compute roots of a cubic (degree 3) polynomial using the
	    cubic formula.  The polynomial should be given as a
	    vector of coefficients.  That is
	    <userinput>4*x^3 + 2*x + 1</userinput> corresponds to the vector
            <userinput>[1,2,0,4]</userinput>.
	    Returns a column vector of the three solutions.  The first solution is always
	    the real one as a cubic always has one real solution.
	  </para>
          <para lang="en">
	    See
	    <ulink url="http://planetmath.org/CubicFormula">Planetmath</ulink>,
	    <ulink url="http://mathworld.wolfram.com/CubicFormula.html">Mathworld</ulink>, or
	    <ulink url="https://en.wikipedia.org/wiki/Cubic_equation">Wikipedia</ulink> for more information.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-EulersMethod"/>EulersMethod</term>
         <listitem>
          <synopsis lang="en">EulersMethod (f,x0,y0,x1,n)</synopsis>
          <para lang="en">
	    Use classical Euler's method to numerically solve y'=f(x,y) for
	    initial <varname>x0</varname>, <varname>y0</varname> going to
	    <varname>x1</varname> with <varname>n</varname> increments,
	    returns <varname>y</varname> at <varname>x1</varname>.
	    Unless you explicitly want to use Euler's method, you should really
	    think about using
	    <link linkend="gel-function-RungeKutta">RungeKutta</link>
	    for solving ODE.
	  </para>
	  <para lang="en">
	    Systems can be solved by just having <varname>y</varname> be a
	    (column) vector everywhere.  That is, <varname>y0</varname> can
	    be a vector in which case <varname>f</varname> should take a number
	    <varname>x</varname> and a vector of the same size for the second
	    argument and should return a vector of the same size.
	  </para>
          <para lang="en">
	    See
	    <ulink url="http://mathworld.wolfram.com/EulerForwardMethod.html">Mathworld</ulink> or
	    <ulink url="https://en.wikipedia.org/wiki/Eulers_method">Wikipedia</ulink> for more information.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-EulersMethodFull"/>EulersMethodFull</term>
         <listitem>
          <synopsis lang="en">EulersMethodFull (f,x0,y0,x1,n)</synopsis>
          <para lang="en">
	    Use classical Euler's method to numerically solve y'=f(x,y) for
	    initial <varname>x0</varname>, <varname>y0</varname> going to
	    <varname>x1</varname> with <varname>n</varname> increments,
	    returns an <userinput>n+1</userinput> by 2 matrix with the
	    <varname>x</varname> and <varname>y</varname> values.
	    Unless you explicitly want to use Euler's method, you should really
	    think about using
	    <link linkend="gel-function-RungeKuttaFull">RungeKuttaFull</link>
	    for solving ODE.
	    Suitable
	    for plugging into 
	    <link linkend="gel-function-LinePlotDrawLine">LinePlotDrawLine</link> or
	    <link linkend="gel-function-LinePlotDrawPoints">LinePlotDrawPoints</link>.
	  </para>
	  <para lang="en">
	    Example:
          <screen lang="en"><prompt>genius&gt;</prompt> <userinput>LinePlotClear();</userinput>
<prompt>genius&gt;</prompt> <userinput>line = EulersMethodFull(`(x,y)=y,0,1.0,3.0,50);</userinput>
<prompt>genius&gt;</prompt> <userinput>LinePlotDrawLine(line,"window","fit","color","blue","legend","Exponential growth");</userinput>
</screen>
	  </para>
	  <para lang="en">
	    Systems can be solved by just having <varname>y</varname> be a
	    (column) vector everywhere.  That is, <varname>y0</varname> can
	    be a vector in which case <varname>f</varname> should take a number
	    <varname>x</varname> and a vector of the same size for the second
	    argument and should return a vector of the same size.
	  </para>
	  <para lang="en">
		  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
		  <link linkend="gel-function-ExpandMatrix">ExpandMatrix</link>,
		  and pick out the right columns.  Example:
          <screen lang="en"><prompt>genius&gt;</prompt> <userinput>LinePlotClear();</userinput>
<prompt>genius&gt;</prompt> <userinput>lines = EulersMethodFull(`(x,y)=[y@(2),-y@(1)],0,[1.0,1.0],10.0,500);</userinput>
<prompt>genius&gt;</prompt> <userinput>lines = ExpandMatrix(lines);</userinput>
<prompt>genius&gt;</prompt> <userinput>firstline = lines@(,[1,2]);</userinput>
<prompt>genius&gt;</prompt> <userinput>secondline = lines@(,[1,3]);</userinput>
<prompt>genius&gt;</prompt> <userinput>LinePlotWindow = [0,10,-2,2];</userinput>
<prompt>genius&gt;</prompt> <userinput>LinePlotDrawLine(firstline,"color","blue","legend","First");</userinput>
<prompt>genius&gt;</prompt> <userinput>LinePlotDrawPoints(secondline,"color","red","thickness",3,"legend","Second");</userinput>
</screen>
	  </para>
          <para lang="en">
	    See
	    <ulink url="http://mathworld.wolfram.com/EulerForwardMethod.html">Mathworld</ulink> or
	    <ulink url="https://en.wikipedia.org/wiki/Eulers_method">Wikipedia</ulink> for more information.
	  </para>
	  <para lang="en">Version 1.0.10 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-FindRootBisection"/>FindRootBisection</term>
         <listitem>
          <synopsis lang="en">FindRootBisection (f,a,b,TOL,N)</synopsis>
          <para lang="en">Find root of a function using the bisection method.
		  <varname>a</varname> and <varname>b</varname> are the initial guess interval,
		  <userinput>f(a)</userinput> and <userinput>f(b)</userinput> should have opposite signs.
	    <varname>TOL</varname> is the desired tolerance and
<varname>N</varname> is the limit on the number of iterations to run, 0 means no limit.  The function returns a vector <userinput>[success,value,iteration]</userinput>, where <varname>success</varname> is a boolean indicating success, <varname>value</varname> is the last value computed, and <varname>iteration</varname> is the number of iterations done.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-FindRootFalsePosition"/>FindRootFalsePosition</term>
         <listitem>
          <synopsis lang="en">FindRootFalsePosition (f,a,b,TOL,N)</synopsis>
          <para lang="en">Find root of a function using the method of false position.
		  <varname>a</varname> and <varname>b</varname> are the initial guess interval,
		  <userinput>f(a)</userinput> and <userinput>f(b)</userinput> should have opposite signs.
	    <varname>TOL</varname> is the desired tolerance and
<varname>N</varname> is the limit on the number of iterations to run, 0 means no limit.  The function returns a vector <userinput>[success,value,iteration]</userinput>, where <varname>success</varname> is a boolean indicating success, <varname>value</varname> is the last value computed, and <varname>iteration</varname> is the number of iterations done.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-FindRootMullersMethod"/>FindRootMullersMethod</term>
         <listitem>
          <synopsis lang="en">FindRootMullersMethod (f,x0,x1,x2,TOL,N)</synopsis>
          <para lang="en">Find root of a function using the Muller's method.
	    <varname>TOL</varname> is the desired tolerance and
<varname>N</varname> is the limit on the number of iterations to run, 0 means no limit.  The function returns a vector <userinput>[success,value,iteration]</userinput>, where <varname>success</varname> is a boolean indicating success, <varname>value</varname> is the last value computed, and <varname>iteration</varname> is the number of iterations done.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-FindRootSecant"/>FindRootSecant</term>
         <listitem>
          <synopsis lang="en">FindRootSecant (f,a,b,TOL,N)</synopsis>
          <para lang="en">Find root of a function using the secant method.
		  <varname>a</varname> and <varname>b</varname> are the initial guess interval,
		  <userinput>f(a)</userinput> and <userinput>f(b)</userinput> should have opposite signs.
	    <varname>TOL</varname> is the desired tolerance and
<varname>N</varname> is the limit on the number of iterations to run, 0 means no limit.  The function returns a vector <userinput>[success,value,iteration]</userinput>, where <varname>success</varname> is a boolean indicating success, <varname>value</varname> is the last value computed, and <varname>iteration</varname> is the number of iterations done.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-HalleysMethod"/>HalleysMethod</term>
         <listitem>
          <synopsis lang="en">HalleysMethod (f,df,ddf,guess,epsilon,maxn)</synopsis>
	  <para lang="en">Find zeros using Halley's method.  <varname>f</varname> is
		  the function, <varname>df</varname> is the derivative of
		  <varname>f</varname>, and <varname>ddf</varname> is the second derivative of
		  <varname>f</varname>.  <varname>guess</varname> is the initial
		  guess.  The function returns after two successive values are
		  within <varname>epsilon</varname> of each other, or after <varname>maxn</varname> tries, in which case the function returns <constant>null</constant> indicating failure.
	  </para>
	  <para lang="en">
	  See also <link linkend="gel-function-NewtonsMethod"><function>NewtonsMethod</function></link> and <link linkend="gel-function-SymbolicDerivative"><function>SymbolicDerivative</function></link>.
  	  </para>
	  <para lang="en">
	    Example to find the square root of 10:
          <screen lang="en"><prompt>genius&gt;</prompt> <userinput>HalleysMethod(`(x)=x^2-10,`(x)=2*x,`(x)=2,3,10^-10,100)</userinput>
</screen>
	  </para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Halley%27s_method">Wikipedia</ulink> for more information.
	  </para>
	  <para lang="en">Version 1.0.18 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-NewtonsMethod"/>NewtonsMethod</term>
         <listitem>
          <synopsis lang="en">NewtonsMethod (f,df,guess,epsilon,maxn)</synopsis>
	  <para lang="en">Find zeros using Newton's method.  <varname>f</varname> is
		  the function and <varname>df</varname> is the derivative of
		  <varname>f</varname>.  <varname>guess</varname> is the initial
		  guess.  The function returns after two successive values are
		  within <varname>epsilon</varname> of each other, or after <varname>maxn</varname> tries, in which case the function returns <constant>null</constant> indicating failure.
	  </para>
	  <para lang="en">
	  See also <link linkend="gel-function-NewtonsMethodPoly"><function>NewtonsMethodPoly</function></link> and <link linkend="gel-function-SymbolicDerivative"><function>SymbolicDerivative</function></link>.
  	  </para>
	  <para lang="en">
	    Example to find the square root of 10:
          <screen lang="en"><prompt>genius&gt;</prompt> <userinput>NewtonsMethod(`(x)=x^2-10,`(x)=2*x,3,10^-10,100)</userinput>
</screen>
	  </para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Newtons_method">Wikipedia</ulink> for more information.
	  </para>
	  <para lang="en">Version 1.0.18 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-PolynomialRoots"/>PolynomialRoots</term>
         <listitem>
          <synopsis lang="en">PolynomialRoots (p)</synopsis>
          <para lang="en">
	    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
	    <userinput>4*x^3 + 2*x + 1</userinput> corresponds to the vector
            <userinput>[1,2,0,4]</userinput>.
	    Returns a column vector of the solutions.
	  </para>
	  <para lang="en">
	    The function calls
	    <link linkend="gel-function-QuadraticFormula">QuadraticFormula</link>,
	    <link linkend="gel-function-CubicFormula">CubicFormula</link>, and
	    <link linkend="gel-function-QuarticFormula">QuarticFormula</link>.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-QuadraticFormula"/>QuadraticFormula</term>
         <listitem>
          <synopsis lang="en">QuadraticFormula (p)</synopsis>
          <para lang="en">
	    Compute roots of a quadratic (degree 2) polynomial using the
	    quadratic formula.  The polynomial should be given as a
	    vector of coefficients.  That is
	    <userinput>3*x^2 + 2*x + 1</userinput> corresponds to the vector
            <userinput>[1,2,3]</userinput>.
	    Returns a column vector of the two solutions.
	  </para>
          <para lang="en">
	    See
	    <ulink url="http://planetmath.org/QuadraticFormula">Planetmath</ulink>, or
	    <ulink url="http://mathworld.wolfram.com/QuadraticFormula.html">Mathworld</ulink>, or
	    <ulink url="https://en.wikipedia.org/wiki/Quadratic_formula">Wikipedia</ulink> for more information.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-QuarticFormula"/>QuarticFormula</term>
         <listitem>
          <synopsis lang="en">QuarticFormula (p)</synopsis>
          <para lang="en">
	    Compute roots of a quartic (degree 4) polynomial using the
	    quartic formula.  The polynomial should be given as a
	    vector of coefficients.  That is
	    <userinput>5*x^4 + 2*x + 1</userinput> corresponds to the vector
            <userinput>[1,2,0,0,5]</userinput>.
	    Returns a column vector of the four solutions.
	  </para>
          <para lang="en">
	    See
	    <ulink url="http://planetmath.org/QuarticFormula">Planetmath</ulink>,
	    <ulink url="http://mathworld.wolfram.com/QuarticEquation.html">Mathworld</ulink>, or
	    <ulink url="https://en.wikipedia.org/wiki/Quartic_equation">Wikipedia</ulink> for more information.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-RungeKutta"/>RungeKutta</term>
         <listitem>
          <synopsis lang="en">RungeKutta (f,x0,y0,x1,n)</synopsis>
          <para lang="en">
	    Use classical non-adaptive fourth order Runge-Kutta method to
	    numerically solve
	    y'=f(x,y) for initial <varname>x0</varname>, <varname>y0</varname>
	    going to <varname>x1</varname> with <varname>n</varname>
	    increments, returns <varname>y</varname> at <varname>x1</varname>.
	  </para>
	  <para lang="en">
	    Systems can be solved by just having <varname>y</varname> be a
	    (column) vector everywhere.  That is, <varname>y0</varname> can
	    be a vector in which case <varname>f</varname> should take a number
	    <varname>x</varname> and a vector of the same size for the second
	    argument and should return a vector of the same size.
	  </para>
          <para lang="en">
	    See
	    <ulink url="http://mathworld.wolfram.com/Runge-KuttaMethod.html">Mathworld</ulink> or
	    <ulink url="https://en.wikipedia.org/wiki/Runge-Kutta_methods">Wikipedia</ulink> for more information.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-RungeKuttaFull"/>RungeKuttaFull</term>
         <listitem>
          <synopsis lang="en">RungeKuttaFull (f,x0,y0,x1,n)</synopsis>
          <para lang="en">
	    Use classical non-adaptive fourth order Runge-Kutta method to
	    numerically solve
	    y'=f(x,y) for initial <varname>x0</varname>, <varname>y0</varname>
	    going to <varname>x1</varname> with <varname>n</varname>
	    increments,
	    returns an <userinput>n+1</userinput> by 2 matrix with the
	    <varname>x</varname> and <varname>y</varname> values.  Suitable
	    for plugging into 
	    <link linkend="gel-function-LinePlotDrawLine">LinePlotDrawLine</link> or
	    <link linkend="gel-function-LinePlotDrawPoints">LinePlotDrawPoints</link>.
	  </para>
	  <para lang="en">
	    Example:
          <screen lang="en"><prompt>genius&gt;</prompt> <userinput>LinePlotClear();</userinput>
<prompt>genius&gt;</prompt> <userinput>line = RungeKuttaFull(`(x,y)=y,0,1.0,3.0,50);</userinput>
<prompt>genius&gt;</prompt> <userinput>LinePlotDrawLine(line,"window","fit","color","blue","legend","Exponential growth");</userinput>
</screen>
	  </para>
	  <para lang="en">
	    Systems can be solved by just having <varname>y</varname> be a
	    (column) vector everywhere.  That is, <varname>y0</varname> can
	    be a vector in which case <varname>f</varname> should take a number
	    <varname>x</varname> and a vector of the same size for the second
	    argument and should return a vector of the same size.
	  </para>
	  <para lang="en">
		  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
		  <link linkend="gel-function-ExpandMatrix">ExpandMatrix</link>,
		  and pick out the right columns.  Example:
          <screen lang="en"><prompt>genius&gt;</prompt> <userinput>LinePlotClear();</userinput>
<prompt>genius&gt;</prompt> <userinput>lines = RungeKuttaFull(`(x,y)=[y@(2),-y@(1)],0,[1.0,1.0],10.0,100);</userinput>
<prompt>genius&gt;</prompt> <userinput>lines = ExpandMatrix(lines);</userinput>
<prompt>genius&gt;</prompt> <userinput>firstline = lines@(,[1,2]);</userinput>
<prompt>genius&gt;</prompt> <userinput>secondline = lines@(,[1,3]);</userinput>
<prompt>genius&gt;</prompt> <userinput>LinePlotWindow = [0,10,-2,2];</userinput>
<prompt>genius&gt;</prompt> <userinput>LinePlotDrawLine(firstline,"color","blue","legend","First");</userinput>
<prompt>genius&gt;</prompt> <userinput>LinePlotDrawPoints(secondline,"color","red","thickness",3,"legend","Second");</userinput>
</screen>
	  </para>
          <para lang="en">
	    See
	    <ulink url="http://mathworld.wolfram.com/Runge-KuttaMethod.html">Mathworld</ulink> or
	    <ulink url="https://en.wikipedia.org/wiki/Runge-Kutta_methods">Wikipedia</ulink> for more information.
	  </para>
	  <para lang="en">Version 1.0.10 onwards.</para>
         </listitem>
        </varlistentry>


      </variablelist>
    </sect1>

    <sect1 id="genius-gel-function-list-statistics">
      <title>Статистика</title>
      <variablelist>
        <varlistentry>
         <term lang="en"><anchor id="gel-function-Average"/>Average</term>
         <listitem>
          <synopsis>Average (m)</synopsis>
          <para lang="en">Aliases: <function>average</function> <function>Mean</function> <function>mean</function></para>
          <para lang="en">Calculate average (the arithmetic mean) of an entire matrix.</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Mean">Wikipedia</ulink> or
	    <ulink url="http://mathworld.wolfram.com/ArithmeticMean.html">Mathworld</ulink> for more information.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-GaussDistribution"/>GaussDistribution</term>
         <listitem>
          <synopsis lang="en">GaussDistribution (x,sigma)</synopsis>
	  <para lang="en">Integral of the GaussFunction from 0 to <varname>x</varname> (area under the normal curve).</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Normal_distribution">Wikipedia</ulink> or
	    <ulink url="http://mathworld.wolfram.com/NormalDistribution.html">Mathworld</ulink> for more information.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-GaussFunction"/>GaussFunction</term>
         <listitem>
          <synopsis lang="en">GaussFunction (x,sigma)</synopsis>
          <para lang="en">The normalized Gauss distribution function (the normal curve).</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Normal_distribution">Wikipedia</ulink> or
	    <ulink url="http://mathworld.wolfram.com/NormalDistribution.html">Mathworld</ulink> for more information.
	  </para>

         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-Median"/>Median</term>
         <listitem>
          <synopsis lang="en">Median (m)</synopsis>
          <para lang="en">Aliases: <function>median</function></para>
          <para lang="en">Calculate median of an entire matrix.</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Median">Wikipedia</ulink> or
	    <ulink url="http://mathworld.wolfram.com/StatisticalMedian.html">Mathworld</ulink> for more information.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-PopulationStandardDeviation"/>PopulationStandardDeviation</term>
         <listitem>
          <synopsis lang="en">PopulationStandardDeviation (m)</synopsis>
          <para lang="en">Aliases: <function>stdevp</function></para>
          <para lang="en">Calculate the population standard deviation of a whole matrix.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-RowAverage"/>RowAverage</term>
         <listitem>
          <synopsis lang="en">RowAverage (m)</synopsis>
          <para lang="en">Aliases: <function>RowMean</function></para>
	  <para lang="en">Calculate average of each row in a matrix.  That is, compute the
	  arithmetic mean.</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Mean">Wikipedia</ulink> or
	    <ulink url="http://mathworld.wolfram.com/ArithmeticMean.html">Mathworld</ulink> for more information.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-RowMedian"/>RowMedian</term>
         <listitem>
          <synopsis lang="en">RowMedian (m)</synopsis>
          <para lang="en">Calculate median of each row in a matrix and return a column
	  vector of the medians.</para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Median">Wikipedia</ulink> or
	    <ulink url="http://mathworld.wolfram.com/StatisticalMedian.html">Mathworld</ulink> for more information.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-RowPopulationStandardDeviation"/>RowPopulationStandardDeviation</term>
         <listitem>
          <synopsis lang="en">RowPopulationStandardDeviation (m)</synopsis>
          <para lang="en">Aliases: <function>rowstdevp</function></para>
          <para lang="en">Calculate the population standard deviations of rows of a matrix and return a vertical vector.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-RowStandardDeviation"/>RowStandardDeviation</term>
         <listitem>
          <synopsis lang="en">RowStandardDeviation (m)</synopsis>
          <para lang="en">Aliases: <function>rowstdev</function></para>
          <para lang="en">Calculate the standard deviations of rows of a matrix and return a vertical vector.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
	 <term lang="en"><anchor id="gel-function-StandardDeviation"/>StandardDeviation</term>
         <listitem>
          <synopsis lang="en">StandardDeviation (m)</synopsis>
          <para lang="en">Aliases: <function>stdev</function></para>
          <para lang="en">Calculate the standard deviation of a whole matrix.</para>
         </listitem>
        </varlistentry>

      </variablelist>
    </sect1>

    <sect1 id="genius-gel-function-list-polynomials">
      <title>Многочлены</title>
      <variablelist>
        <varlistentry>
         <term lang="en"><anchor id="gel-function-AddPoly"/>AddPoly</term>
         <listitem>
          <synopsis>AddPoly (p1,p2)</synopsis>
          <para>Складывает два многочлена (в виде векторов).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-DividePoly"/>DividePoly</term>
         <listitem>
          <synopsis lang="en">DividePoly (p,q,&amp;r)</synopsis>
          <para lang="en">Divide two polynomials (as vectors) using long division.
	   Returns the quotient
	   of the two polynomials.  The optional argument <varname>r</varname>
	   is used to return the remainder.  The remainder will have lower
	   degree than <varname>q</varname>.</para>
          <para lang="en">
	    See
	    <ulink url="http://planetmath.org/PolynomialLongDivision">Planetmath</ulink> for more information.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-IsPoly"/>IsPoly</term>
         <listitem>
          <synopsis>IsPoly (p)</synopsis>
          <para>Проверяет, можно ли использовать вектор в качестве многочлена.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-MultiplyPoly"/>MultiplyPoly</term>
         <listitem>
          <synopsis>MultiplyPoly (p1,p2)</synopsis>
          <para>Умножает два многочлена (в виде векторов).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-NewtonsMethodPoly"/>NewtonsMethodPoly</term>
         <listitem>
          <synopsis lang="en">NewtonsMethodPoly (poly,guess,epsilon,maxn)</synopsis>
	  <para lang="en">Find a root of a polynomial using Newton's method.  <varname>poly</varname> is
		  the polynomial as a vector and <varname>guess</varname> is the initial
		  guess.  The function returns after two successive values are
		  within <varname>epsilon</varname> of each other, or after <varname>maxn</varname> tries, in which case the function returns <constant>null</constant> indicating failure.
	  </para>
	  <para lang="en">
	  See also <link linkend="gel-function-NewtonsMethod"><function>NewtonsMethod</function></link>.
  	  </para>
	  <para lang="en">
	    Example to find the square root of 10:
          <screen lang="en"><prompt>genius&gt;</prompt> <userinput>NewtonsMethodPoly([-10,0,1],3,10^-10,100)</userinput>
</screen>
	  </para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Newtons_method">Wikipedia</ulink> for more information.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-Poly2ndDerivative"/>Poly2ndDerivative</term>
         <listitem>
          <synopsis>Poly2ndDerivative (p)</synopsis>
          <para>Находит вторую производную многочлена (как вектора).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-PolyDerivative"/>PolyDerivative</term>
         <listitem>
          <synopsis>PolyDerivative (p)</synopsis>
          <para>Находит производную многочлена (как вектора).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-PolyToFunction"/>PolyToFunction</term>
         <listitem>
          <synopsis lang="en">PolyToFunction (p)</synopsis>
          <para lang="en">Make function out of a polynomial (as vector).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-PolyToString"/>PolyToString</term>
         <listitem>
          <synopsis lang="en">PolyToString (p,var...)</synopsis>
          <para lang="en">Make string out of a polynomial (as vector).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-SubtractPoly"/>SubtractPoly</term>
         <listitem>
          <synopsis lang="en">SubtractPoly (p1,p2)</synopsis>
          <para lang="en">Subtract two polynomials (as vectors).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-TrimPoly"/>TrimPoly</term>
         <listitem>
          <synopsis lang="en">TrimPoly (p)</synopsis>
          <para lang="en">Trim zeros from a polynomial (as vector).</para>
         </listitem>
        </varlistentry>

      </variablelist>
    </sect1>

    <sect1 id="genius-gel-function-list-set-theory">
      <title>Теория множеств</title>
      <variablelist>
        <varlistentry>
         <term lang="en"><anchor id="gel-function-Intersection"/>Intersection</term>
         <listitem>
          <synopsis>Intersection (X,Y)</synopsis>
          <para>Возвращает пересечение множеств X и Y (X и Y — векторы, изображающие множества).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-IsIn"/>IsIn</term>
         <listitem>
          <synopsis>IsIn (x,X)</synopsis>
	  <para>Возвращает <constant>true</constant>, если элемент x присуствует в множестве X (где X — вектор, изображающий множество).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-IsSubset"/>IsSubset</term>
         <listitem>
          <synopsis>IsSubset (X, Y)</synopsis>
	  <para>Возвращает <constant>true</constant>, если X является подмножеством Y (X и Y — векторы, изображающие множество).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-MakeSet"/>MakeSet</term>
         <listitem>
          <synopsis lang="en">MakeSet (X)</synopsis>
          <para lang="en">Returns a vector where every element of X appears only once.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-SetMinus"/>SetMinus</term>
         <listitem>
          <synopsis lang="en">SetMinus (X,Y)</synopsis>
          <para lang="en">Returns a set theoretic difference X-Y (X and Y are vectors pretending to be sets).</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-Union"/>Union</term>
         <listitem>
          <synopsis>Union (X,Y)</synopsis>
          <para>Возвращает объединение множеств X и Y (X и Y — векторы, изображающие множества).</para>
         </listitem>
        </varlistentry>

      </variablelist>
    </sect1>

    <sect1 id="genius-gel-function-list-commutative-algebra">
      <title lang="en">Commutative Algebra</title>
      <variablelist>
        <varlistentry>
         <term lang="en"><anchor id="gel-function-MacaulayBound"/>MacaulayBound</term>
         <listitem>
          <synopsis lang="en">MacaulayBound (c,d)</synopsis>
          <para lang="en">For a Hilbert function that is c for degree d, given the Macaulay bound for the Hilbert function of degree d+1 (The c^&lt;d&gt; operator from Green's proof).</para>
	  <para lang="en">Version 1.0.15 onwards.</para>
         </listitem>
        </varlistentry>
	
        <varlistentry>
         <term lang="en"><anchor id="gel-function-MacaulayLowerOperator"/>MacaulayLowerOperator</term>
         <listitem>
          <synopsis lang="en">MacaulayLowerOperator (c,d)</synopsis>
          <para lang="en">The c_&lt;d&gt; operator from Green's proof of Macaulay's Theorem.</para>
	  <para lang="en">Version 1.0.15 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-MacaulayRep"/>MacaulayRep</term>
         <listitem>
          <synopsis lang="en">MacaulayRep (c,d)</synopsis>
          <para lang="en">Return the dth Macaulay representation of a positive integer c.</para>
	  <para lang="en">Version 1.0.15 onwards.</para>
         </listitem>
        </varlistentry>
      </variablelist>
    </sect1>

    <sect1 id="genius-gel-function-list-miscellaneous">
      <title>Прочие</title>
      <variablelist>
        <varlistentry>
         <term lang="en"><anchor id="gel-function-ASCIIToString"/>ASCIIToString</term>
         <listitem>
          <synopsis>ASCIIToString (vec)</synopsis>
          <para lang="en">Convert a vector of ASCII values to a string.
		  See also
		  <link linkend="gel-function-StringToASCII"><function>StringToASCII</function></link>.
          </para>
          <para lang="en">
	    Example:
          <screen lang="en"><prompt>genius&gt;</prompt> <userinput>ASCIIToString([97,98,99])</userinput>
= "abc"
</screen>
          </para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/ASCII">Wikipedia</ulink> for more information.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-AlphabetToString"/>AlphabetToString</term>
         <listitem>
          <synopsis>AlphabetToString (vec,alphabet)</synopsis>
	  <para lang="en">Convert a vector of 0-based alphabet values (positions in the alphabet string) to a string.  A <constant>null</constant> vector results in an empty string.
		  See also
		  <link linkend="gel-function-StringToAlphabet"><function>StringToAlphabet</function></link>.
          </para>
          <para lang="en">
	    Examples:
          <screen lang="en"><prompt>genius&gt;</prompt> <userinput>AlphabetToString([1,2,3,0,0],"abcd")</userinput>
= "bcdaa"
<prompt>genius&gt;</prompt> <userinput>AlphabetToString(null,"abcd")</userinput>
= ""
</screen>
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-StringToASCII"/>StringToASCII</term>
         <listitem>
          <synopsis>StringToASCII (str)</synopsis>
	  <para lang="en">Convert a string to a (row) vector of ASCII values.
		  See also
		  <link linkend="gel-function-ASCIIToString"><function>ASCIIToString</function></link>.
          </para>
          <para lang="en">
	    Example:
          <screen lang="en"><prompt>genius&gt;</prompt> <userinput>StringToASCII("abc")</userinput>
= [97, 98, 99]
</screen>
          </para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/ASCII">Wikipedia</ulink> for more information.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-StringToAlphabet"/>StringToAlphabet</term>
         <listitem>
          <synopsis>StringToAlphabet (str,alphabet)</synopsis>
	  <para lang="en">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 <constant>null</constant>.
		  See also
		  <link linkend="gel-function-AlphabetToString"><function>AlphabetToString</function></link>.
          </para>
          <para lang="en">
	    Examples:
          <screen lang="en"><prompt>genius&gt;</prompt> <userinput>StringToAlphabet("cca","abcd")</userinput>
= [2, 2, 0]
<prompt>genius&gt;</prompt> <userinput>StringToAlphabet("ccag","abcd")</userinput>
= [2, 2, 0, -1]
</screen>
          </para>
         </listitem>
        </varlistentry>

      </variablelist>
    </sect1>

    <sect1 id="genius-gel-function-list-symbolic">
      <title lang="en">Symbolic Operations</title>
      <variablelist>
        <varlistentry>
         <term lang="en"><anchor id="gel-function-SymbolicDerivative"/>SymbolicDerivative</term>
         <listitem>
          <synopsis lang="en">SymbolicDerivative (f)</synopsis>
          <para lang="en">Attempt to symbolically differentiate the function f, where f is a function of one variable.</para>
          <para lang="en">
	    Examples:
          <screen lang="en"><prompt>genius&gt;</prompt> <userinput>SymbolicDerivative(sin)</userinput>
= (`(x)=cos(x))
<prompt>genius&gt;</prompt> <userinput>SymbolicDerivative(`(x)=7*x^2)</userinput>
= (`(x)=(7*(2*x)))
</screen>
          </para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Derivative">Wikipedia</ulink> for more information.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-SymbolicDerivativeTry"/>SymbolicDerivativeTry</term>
         <listitem>
          <synopsis lang="en">SymbolicDerivativeTry (f)</synopsis>
	  <para lang="en">Attempt to symbolically differentiate the function f, where f is a function of one variable, returns <constant>null</constant> if unsuccessful but is silent.
	  (See <link linkend="gel-function-SymbolicDerivative"><function>SymbolicDerivative</function></link>)
          </para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Derivative">Wikipedia</ulink> for more information.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-SymbolicNthDerivative"/>SymbolicNthDerivative</term>
         <listitem>
          <synopsis lang="en">SymbolicNthDerivative (f,n)</synopsis>
          <para lang="en">Attempt to symbolically differentiate a function n times.
	  (See <link linkend="gel-function-SymbolicDerivative"><function>SymbolicDerivative</function></link>)
          </para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Derivative">Wikipedia</ulink> for more information.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-SymbolicNthDerivativeTry"/>SymbolicNthDerivativeTry</term>
         <listitem>
          <synopsis lang="en">SymbolicNthDerivativeTry (f,n)</synopsis>
	  <para lang="en">Attempt to symbolically differentiate a function n times quietly and return <constant>null</constant> on failure
	  (See <link linkend="gel-function-SymbolicNthDerivative"><function>SymbolicNthDerivative</function></link>)
          </para>
          <para lang="en">
	    See
	    <ulink url="https://en.wikipedia.org/wiki/Derivative">Wikipedia</ulink> for more information.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-SymbolicTaylorApproximationFunction"/>SymbolicTaylorApproximationFunction</term>
         <listitem>
          <synopsis lang="en">SymbolicTaylorApproximationFunction (f,x0,n)</synopsis>
	  <para lang="en">Attempt to construct the Taylor approximation function around x0 to the nth degree.
	  (See <link linkend="gel-function-SymbolicDerivative"><function>SymbolicDerivative</function></link>)
          </para>
         </listitem>
        </varlistentry>
      </variablelist>
    </sect1>

    <sect1 id="genius-gel-function-list-plotting">
      <title>Построение графиков</title>
      <variablelist>
        <varlistentry>
         <term lang="en"><anchor id="gel-function-ExportPlot"/>ExportPlot</term>
         <listitem>
          <synopsis lang="en">ExportPlot (file,type)</synopsis>
          <synopsis lang="en">ExportPlot (file)</synopsis>
          <para lang="en">
		  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".
	  </para>
	  <para lang="en">
		  Note that files are overwritten without asking.
	  </para>
	  <para lang="en">
		  On successful export, true is returned.  Otherwise
		  error is printed and exception is raised.
	  </para>
          <para lang="en">
	    Examples:
          <screen lang="en"><prompt>genius&gt;</prompt> <userinput>ExportPlot("file.png")</userinput>
<prompt>genius&gt;</prompt> <userinput>ExportPlot("/directory/file","eps")</userinput>
</screen>
          </para>
	  <para lang="en">Version 1.0.16 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-LinePlot"/>LinePlot</term>
         <listitem>
          <synopsis lang="en">LinePlot (func1,func2,func3,...)</synopsis>
          <synopsis lang="en">LinePlot (func1,func2,func3,x1,x2)</synopsis>
          <synopsis lang="en">LinePlot (func1,func2,func3,x1,x2,y1,y2)</synopsis>
          <synopsis lang="en">LinePlot (func1,func2,func3,[x1,x2])</synopsis>
          <synopsis lang="en">LinePlot (func1,func2,func3,[x1,x2,y1,y2])</synopsis>
          <para lang="en">
	    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
	    <varname>x1</varname>, <varname>x2</varname>,
	    <varname>y1</varname>, <varname>y2</varname>.  If limits are not
	    specified, then the currently set limits apply
	    (See <link linkend="gel-function-LinePlotWindow"><function>LinePlotWindow</function></link>)
	    If the y limits are not specified, then the functions are computed and then the maxima and minima
	    are used.
          </para>
          <para lang="en">
	    The parameter
	    <link linkend="gel-function-LinePlotDrawLegends"><function>LinePlotDrawLegends</function></link>
	    controls the drawing of the legend.
	  </para>
          <para lang="en">
	    Examples:
          <screen lang="en"><prompt>genius&gt;</prompt> <userinput>LinePlot(sin,cos)</userinput>
<prompt>genius&gt;</prompt> <userinput>LinePlot(`(x)=x^2,-1,1,0,1)</userinput>
</screen>
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-LinePlotClear"/>LinePlotClear</term>
         <listitem>
          <synopsis lang="en">LinePlotClear ()</synopsis>
          <para lang="en">
            Show the line plot window and clear out functions and any other
            lines that were drawn.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-LinePlotCParametric"/>LinePlotCParametric</term>
         <listitem>
          <synopsis lang="en">LinePlotCParametric (func,...)</synopsis>
          <synopsis lang="en">LinePlotCParametric (func,t1,t2,tinc)</synopsis>
          <synopsis lang="en">LinePlotCParametric (func,t1,t2,tinc,x1,x2,y1,y2)</synopsis>
          <para lang="en">
	    Plot a parametric complex valued function with a line.  First comes
the function that returns <computeroutput>x+iy</computeroutput>,
then optionally the <varname>t</varname> limits as <userinput>t1,t2,tinc</userinput>, then
optionally the limits as <userinput>x1,x2,y1,y2</userinput>.
          </para>
	  <para lang="en">
	    If limits are not
	    specified, then the currently set limits apply
	    (See <link linkend="gel-function-LinePlotWindow"><function>LinePlotWindow</function></link>).
	    If instead the string "fit" is given for the x and y limits, then the limits are the maximum extent of
	    the graph
          </para>
          <para lang="en">
	    The parameter
	    <link linkend="gel-function-LinePlotDrawLegends"><function>LinePlotDrawLegends</function></link>
	    controls the drawing of the legend.
	  </para>
         </listitem>
        </varlistentry>


        <varlistentry>
         <term lang="en"><anchor id="gel-function-LinePlotDrawLine"/>LinePlotDrawLine</term>
         <listitem>
          <synopsis lang="en">LinePlotDrawLine (x1,y1,x2,y2,...)</synopsis>
          <synopsis lang="en">LinePlotDrawLine (v,...)</synopsis>
          <para lang="en">
	    Draw a line from <varname>x1</varname>,<varname>y1</varname> to
	    <varname>x2</varname>,<varname>y2</varname>.
	    <varname>x1</varname>,<varname>y1</varname>,
	    <varname>x2</varname>,<varname>y2</varname> can be replaced by an
	    <varname>n</varname> by 2 matrix for a longer polyline.
	    Alternatively the vector <varname>v</varname> may be a column vector of complex numbers,
	    that is an <varname>n</varname> by 1 matrix and each complex number is then
	    considered a point in the plane.
          </para>
          <para lang="en">
	    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 <userinput>"color"</userinput>, 
	    <userinput>"thickness"</userinput>,
	    <userinput>"window"</userinput>, 
	    <userinput>"arrow"</userinput>, or <userinput>"legend"</userinput>, 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.)
    	  </para>
	  <para lang="en">
	    If the line is to be treated as a filled polygon, filled with the given color, you
	    can specify the argument <userinput>"filled"</userinput>.  Since version 1.0.22 onwards.
	  </para>
    	  <para lang="en">
	    The color should be either a string indicating the common English word for the color
	    that GTK will recognize such as 
            <userinput>"red"</userinput>, <userinput>"blue"</userinput>, <userinput>"yellow"</userinput>, etc...
	    Alternatively the color can be specified in RGB format as
	    <userinput>"#rgb"</userinput>, <userinput>"#rrggbb"</userinput>, or
	    <userinput>"#rrrrggggbbbb"</userinput>, 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. <userinput>[1.0,0.5,0.1]</userinput>.
    	  </para>
    	  <para lang="en">
	    The window should be given as usual as <userinput>[x1,x2,y1,y2]</userinput>, or
	    alternatively can be given as a string
	    <userinput>"fit"</userinput> in which case,
	    the x range will be set precisely and the y range will be set with
	    five percent borders around the line.
    	  </para>
    	  <para lang="en">
	    Arrow specification should be
	    <userinput>"origin"</userinput>,
	    <userinput>"end"</userinput>,
	    <userinput>"both"</userinput>, or
	    <userinput>"none"</userinput>.
    	  </para>
    	  <para lang="en">
	    Finally, legend should be a string that can be used as the legend in the
	    graph.  That is, if legends are being printed.
          </para>
	  <para lang="en">
	  Examples:
          <screen lang="en"><prompt>genius&gt;</prompt> <userinput>LinePlotDrawLine(0,0,1,1,"color","blue","thickness",3)</userinput>
<prompt>genius&gt;</prompt> <userinput>LinePlotDrawLine([0,0;1,-1;-1,-1])</userinput>
<prompt>genius&gt;</prompt> <userinput>LinePlotDrawLine([0,0;1,1],"arrow","end")</userinput>
<prompt>genius&gt;</prompt> <userinput>LinePlotDrawLine(RungeKuttaFull(`(x,y)=y,0,0.001,10,100),"color","blue","legend","The Solution")</userinput>
<prompt>genius&gt;</prompt> <userinput>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])</userinput>
<prompt>genius&gt;</prompt> <userinput>LinePlotDrawLine([0,0;10,0;10,10;0,10],"filled","color","green")</userinput>
</screen>
          </para>
	  <para lang="en">
		  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.
	  </para>
	  <para lang="en">
		  Specifying <varname>v</varname> as a column vector of complex numbers is
		  implemented from version 1.0.22 and onwards.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-LinePlotDrawPoints"/>LinePlotDrawPoints</term>
         <listitem>
          <synopsis lang="en">LinePlotDrawPoints (x,y,...)</synopsis>
          <synopsis lang="en">LinePlotDrawPoints (v,...)</synopsis>
          <para lang="en">
		  Draw a point at <varname>x</varname>,<varname>y</varname>.
		  The input can be an <varname>n</varname> by 2 matrix
		  for <varname>n</varname> different points.  This function has essentially the same
		  input as <link linkend="gel-function-LinePlotDrawLine">LinePlotDrawLine</link>.
		  Alternatively the vector <varname>v</varname> may be a column vector of complex numbers,
		  that is an <varname>n</varname> by 1 matrix and each complex number is then
		  considered a point in the plane.
          </para>
          <para lang="en">
	    Extra parameters can be added to specify color, thickness,
	    the plotting window, or legend.
	    You can do this by adding an argument string <userinput>"color"</userinput>, 
	    <userinput>"thickness"</userinput>,
	    <userinput>"window"</userinput>, 
	    or <userinput>"legend"</userinput>, and after it specify
	    the color, the thickness, the window
	    as 4-vector, or the legend.
    	  </para>
    	  <para lang="en">
	    The color should be either a string indicating the common English word for the color
	    that GTK will recognize such as 
            <userinput>"red"</userinput>, <userinput>"blue"</userinput>, <userinput>"yellow"</userinput>, etc...
	    Alternatively the color can be specified in RGB format as
	    <userinput>"#rgb"</userinput>, <userinput>"#rrggbb"</userinput>, or
	    <userinput>"#rrrrggggbbbb"</userinput>, 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.
    	  </para>
    	  <para lang="en">
	    The window should be given as usual as <userinput>[x1,x2,y1,y2]</userinput>, or
	    alternatively can be given as a string
	    <userinput>"fit"</userinput> in which case,
	    the x range will be set precisely and the y range will be set with
	    five percent borders around the line.
    	  </para>
    	  <para lang="en">
	    Finally, legend should be a string that can be used as the legend in the
	    graph.  That is, if legends are being printed.
          </para>
	  <para lang="en">
	  Examples:
          <screen lang="en"><prompt>genius&gt;</prompt> <userinput>LinePlotDrawPoints(0,0,"color","blue","thickness",3)</userinput>
<prompt>genius&gt;</prompt> <userinput>LinePlotDrawPoints([0,0;1,-1;-1,-1])</userinput>
<prompt>genius&gt;</prompt> <userinput>LinePlotDrawPoints(RungeKuttaFull(`(x,y)=y,0,0.001,10,100),"color","blue","legend","The Solution")</userinput>
<prompt>genius&gt;</prompt> <userinput>LinePlotDrawPoints([1;1+1i;1i;0],"thickness",5)</userinput>
<prompt>genius&gt;</prompt> <userinput>LinePlotDrawPoints(ApplyOverMatrix((0:6)',`(k)=exp(k*2*pi*1i/7)),"thickness",3,"legend","The 7th roots of unity")</userinput>
</screen>
          </para>
	  <para lang="en">
		  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 <userinput>0:6</userinput>
		  to make it into a column vector.
	  </para>
	  <para lang="en">
		  Available from version 1.0.18 onwards.  Specifying
		  <varname>v</varname> as a column vector of complex numbers is
		  implemented from version 1.0.22 and onwards.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-LinePlotMouseLocation"/>LinePlotMouseLocation</term>
         <listitem>
          <synopsis lang="en">LinePlotMouseLocation ()</synopsis>
          <para lang="en">
	    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 <constant>null</constant>.
	    In this case you should run
	    <link linkend="gel-function-LinePlot"><function>LinePlot</function></link> or
	    <link linkend="gel-function-LinePlotClear"><function>LinePlotClear</function></link>
	    to put the graphing window into the line plot mode.
	    See also
	    <link linkend="gel-function-LinePlotWaitForClick"><function>LinePlotWaitForClick</function></link>.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-LinePlotParametric"/>LinePlotParametric</term>
         <listitem>
          <synopsis lang="en">LinePlotParametric (xfunc,yfunc,...)</synopsis>
          <synopsis lang="en">LinePlotParametric (xfunc,yfunc,t1,t2,tinc)</synopsis>
          <synopsis lang="en">LinePlotParametric (xfunc,yfunc,t1,t2,tinc,x1,x2,y1,y2)</synopsis>
          <synopsis lang="en">LinePlotParametric (xfunc,yfunc,t1,t2,tinc,[x1,x2,y1,y2])</synopsis>
          <synopsis lang="en">LinePlotParametric (xfunc,yfunc,t1,t2,tinc,"fit")</synopsis>
          <para lang="en">
	    Plot a parametric function with a line.  First come the functions
for <varname>x</varname> and <varname>y</varname> then optionally the <varname>t</varname> limits as <userinput>t1,t2,tinc</userinput>, then optionally the
limits as <userinput>x1,x2,y1,y2</userinput>.
          </para>
	  <para lang="en">
	    If x and y limits are not
	    specified, then the currently set limits apply
	    (See <link linkend="gel-function-LinePlotWindow"><function>LinePlotWindow</function></link>).
	    If instead the string "fit" is given for the x and y limits, then the limits are the maximum extent of
	    the graph
          </para>
          <para lang="en">
	    The parameter
	    <link linkend="gel-function-LinePlotDrawLegends"><function>LinePlotDrawLegends</function></link>
	    controls the drawing of the legend.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-LinePlotWaitForClick"/>LinePlotWaitForClick</term>
         <listitem>
          <synopsis lang="en">LinePlotWaitForClick ()</synopsis>
          <para lang="en">
	    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 <constant>null</constant>.
	    If the window is not in line plot mode, it is put in it and shown
	    if not shown.
	    See also
	    <link linkend="gel-function-LinePlotMouseLocation"><function>LinePlotMouseLocation</function></link>.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-PlotCanvasFreeze"/>PlotCanvasFreeze</term>
         <listitem>
          <synopsis lang="en">PlotCanvasFreeze ()</synopsis>
          <para lang="en">
		  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 <link linkend="gel-function-PlotCanvasThaw"><function>PlotCanvasThaw</function></link>.
          </para>
          <para lang="en">
		  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.
          </para>
	  <para lang="en">Version 1.0.18 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-PlotCanvasThaw"/>PlotCanvasThaw</term>
         <listitem>
          <synopsis lang="en">PlotCanvasThaw ()</synopsis>
          <para lang="en">
		  Thaw the plot canvas frozen by
		  <link linkend="gel-function-PlotCanvasFreeze"><function>PlotCanvasFreeze</function></link>
		  and redraw the canvas immediately.  The canvas is also always thawed after end of execution
		  of any program.
          </para>
	  <para lang="en">Version 1.0.18 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-PlotWindowPresent"/>PlotWindowPresent</term>
         <listitem>
          <synopsis lang="en">PlotWindowPresent ()</synopsis>
          <para lang="en">
		  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.
          </para>
	  <para lang="en">Version 1.0.19 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-SlopefieldClearSolutions"/>SlopefieldClearSolutions</term>
         <listitem>
          <synopsis lang="en">SlopefieldClearSolutions ()</synopsis>
          <para lang="en">
	    Clears the solutions drawn by the
	    <link linkend="gel-function-SlopefieldDrawSolution"><function>SlopefieldDrawSolution</function></link>
	    function.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-SlopefieldDrawSolution"/>SlopefieldDrawSolution</term>
         <listitem>
          <synopsis lang="en">SlopefieldDrawSolution (x, y, dx)</synopsis>
          <para lang="en">
	    When a slope field plot is active, draw a solution with
	    the specified initial condition.  The standard
	    Runge-Kutta method is used with increment <varname>dx</varname>.
	    Solutions stay on the graph until a different plot is shown or until
	    you call 
	    <link linkend="gel-function-SlopefieldClearSolutions"><function>SlopefieldClearSolutions</function></link>.
	    You can also use the graphical interface to draw solutions and specify
	    initial conditions with the mouse.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-SlopefieldPlot"/>SlopefieldPlot</term>
         <listitem>
          <synopsis lang="en">SlopefieldPlot (func)</synopsis>
          <synopsis lang="en">SlopefieldPlot (func,x1,x2,y1,y2)</synopsis>
          <para lang="en">
	    Plot a slope field.  The function <varname>func</varname>
	    should take two real numbers <varname>x</varname>
	    and <varname>y</varname>, or a single complex
	    number.
            Optionally you can specify the limits of the plotting window as
	    <varname>x1</varname>, <varname>x2</varname>,
	    <varname>y1</varname>, <varname>y2</varname>.  If limits are not
	    specified, then the currently set limits apply
	    (See <link linkend="gel-function-LinePlotWindow"><function>LinePlotWindow</function></link>).
          </para>
          <para lang="en">
	    The parameter
	    <link linkend="gel-function-LinePlotDrawLegends"><function>LinePlotDrawLegends</function></link>
	    controls the drawing of the legend.
	  </para>
          <para lang="en">
	    Examples:
          <screen lang="en"><prompt>genius&gt;</prompt> <userinput>SlopefieldPlot(`(x,y)=sin(x-y),-5,5,-5,5)</userinput>
</screen>
          </para>
         </listitem>
        </varlistentry>

	<varlistentry>
	 <term lang="en"><anchor id="gel-function-SurfacePlot"/>SurfacePlot</term>
         <listitem>
          <synopsis lang="en">SurfacePlot (func)</synopsis>
          <synopsis lang="en">SurfacePlot (func,x1,x2,y1,y2,z1,z2)</synopsis>
          <synopsis lang="en">SurfacePlot (func,x1,x2,y1,y2)</synopsis>
          <synopsis lang="en">SurfacePlot (func,[x1,x2,y1,y2,z1,z2])</synopsis>
          <synopsis lang="en">SurfacePlot (func,[x1,x2,y1,y2])</synopsis>
          <para lang="en">
	    Plot a surface function that takes either two arguments or a complex number.  First comes the function then optionally limits as <varname>x1</varname>, <varname>x2</varname>,
	    <varname>y1</varname>, <varname>y2</varname>,
	    <varname>z1</varname>, <varname>z2</varname>.  If limits are not
	    specified, then the currently set limits apply
	    (See <link linkend="gel-function-SurfacePlotWindow"><function>SurfacePlotWindow</function></link>).
	    Genius can only plot a single surface function at this time.
          </para>
          <para lang="en">
	    If the z limits are not specified then the maxima and minima of the function are used.
	  </para>
          <para lang="en">
	    Examples:
          <screen lang="en"><prompt>genius&gt;</prompt> <userinput>SurfacePlot(|sin|,-1,1,-1,1,0,1.5)</userinput>
<prompt>genius&gt;</prompt> <userinput>SurfacePlot(`(x,y)=x^2+y,-1,1,-1,1,-2,2)</userinput>
<prompt>genius&gt;</prompt> <userinput>SurfacePlot(`(z)=|z|^2,-1,1,-1,1,0,2)</userinput>
</screen>
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-SurfacePlotClear"/>SurfacePlotClear</term>
         <listitem>
          <synopsis lang="en">SurfacePlotClear ()</synopsis>
          <para lang="en">
            Show the surface plot window and clear out functions and any other
            lines that were drawn.
          </para>
          <para lang="en">
	    Available in version 1.0.19 and onwards.
          </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-SurfacePlotData"/>SurfacePlotData</term>
         <listitem>
          <synopsis lang="en">SurfacePlotData (data)</synopsis>
          <synopsis lang="en">SurfacePlotData (data,label)</synopsis>
          <synopsis lang="en">SurfacePlotData (data,x1,x2,y1,y2,z1,z2)</synopsis>
          <synopsis lang="en">SurfacePlotData (data,label,x1,x2,y1,y2,z1,z2)</synopsis>
          <synopsis lang="en">SurfacePlotData (data,[x1,x2,y1,y2,z1,z2])</synopsis>
          <synopsis lang="en">SurfacePlotData (data,label,[x1,x2,y1,y2,z1,z2])</synopsis>
          <para lang="en">
		  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.
	  </para>
          <para lang="en">
		  Optionally we can give the label and also optionally the
		  limits.  If limits are not given, they are computed from
		  the data, <link linkend="gel-function-SurfacePlotWindow"><function>SurfacePlotWindow</function></link>
		  is not used, if you want to use it, pass it in explicitly.
		  If label is not given then empty label is used.
	  </para>
          <para lang="en">
	    Examples:
          <screen lang="en"><prompt>genius&gt;</prompt> <userinput>SurfacePlotData([0,0,0;1,0,1;0,1,1;1,1,3])</userinput>
<prompt>genius&gt;</prompt> <userinput>SurfacePlotData(data,"My data")</userinput>
<prompt>genius&gt;</prompt> <userinput>SurfacePlotData(data,-1,1,-1,1,0,10)</userinput>
<prompt>genius&gt;</prompt> <userinput>SurfacePlotData(data,SurfacePlotWindow)</userinput>
</screen>
          </para>
	  <para lang="en">
		  Here's an example of how to plot in polar coordinates,
		  in particular how to plot the function
		  <userinput>-r^2 * theta</userinput>:
          <screen lang="en"><prompt>genius&gt;</prompt> <userinput>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]];</userinput>
<prompt>genius&gt;</prompt> <userinput>SurfacePlotData(d)</userinput>
</screen>
          </para>
	  <para lang="en">Version 1.0.16 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-SurfacePlotDataGrid"/>SurfacePlotDataGrid</term>
         <listitem>
          <synopsis lang="en">SurfacePlotDataGrid (data,[x1,x2,y1,y2])</synopsis>
          <synopsis lang="en">SurfacePlotDataGrid (data,[x1,x2,y1,y2,z1,z2])</synopsis>
          <synopsis lang="en">SurfacePlotDataGrid (data,[x1,x2,y1,y2],label)</synopsis>
          <synopsis lang="en">SurfacePlotDataGrid (data,[x1,x2,y1,y2,z1,z2],label)</synopsis>
          <para lang="en">
		  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 <varname>x1</varname> and <varname>x2</varname>
		  give the interval on the x-axis that we use, and 
		  the limits <varname>y1</varname> and <varname>y2</varname>
		  give the interval on the y-axis that we use.
		  If the limits <varname>z1</varname> and <varname>z2</varname>
		  are not given they are computed from the data (to be
		  the extreme values from the data).
	  </para>
          <para lang="en">
		  Optionally we can give the label, if label is not given then
		  empty label is used.
	  </para>
          <para lang="en">
	    Examples:
          <screen lang="en"><prompt>genius&gt;</prompt> <userinput>SurfacePlotDataGrid([1,2;3,4],[0,1,0,1])</userinput>
<prompt>genius&gt;</prompt> <userinput>SurfacePlotDataGrid(data,[-1,1,-1,1],"My data")</userinput>
<prompt>genius&gt;</prompt> <userinput>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;</userinput>
<prompt>genius&gt;</prompt> <userinput>SurfacePlotDataGrid(d,[-1,1,0,1],"half a saddle")</userinput>
</screen>
          </para>
	  <para lang="en">Version 1.0.16 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-SurfacePlotDrawLine"/>SurfacePlotDrawLine</term>
         <listitem>
          <synopsis lang="en">SurfacePlotDrawLine (x1,y1,z1,x2,y2,z2,...)</synopsis>
          <synopsis lang="en">SurfacePlotDrawLine (v,...)</synopsis>
          <para lang="en">
	    Draw a line from <varname>x1</varname>,<varname>y1</varname>,<varname>z1</varname> to
	    <varname>x2</varname>,<varname>y2</varname>,<varname>z2</varname>.
	    <varname>x1</varname>,<varname>y1</varname>,<varname>z1</varname>,
	    <varname>x2</varname>,<varname>y2</varname>,<varname>z2</varname> can be replaced by an
	    <varname>n</varname> by 3 matrix for a longer polyline.
          </para>
          <para lang="en">
	    Extra parameters can be added to specify line color, thickness,
	    the plotting window, or legend.
	    You can do this by adding an argument string <userinput>"color"</userinput>, 
	    <userinput>"thickness"</userinput>,
	    <userinput>"window"</userinput>,
	    or <userinput>"legend"</userinput>, and after it specify
	    the color, the thickness, the window
	    as 6-vector, or the legend.
    	  </para>
    	  <para lang="en">
	    The color should be either a string indicating the common English word for the color
	    that GTK will recognize such as 
            <userinput>"red"</userinput>, <userinput>"blue"</userinput>, <userinput>"yellow"</userinput>, etc...
	    Alternatively the color can be specified in RGB format as
	    <userinput>"#rgb"</userinput>, <userinput>"#rrggbb"</userinput>, or
	    <userinput>"#rrrrggggbbbb"</userinput>, 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. <userinput>[1.0,0.5,0.1]</userinput>.
    	  </para>
    	  <para lang="en">
	    The window should be given as usual as <userinput>[x1,x2,y1,y2,z1,z2]</userinput>, or
	    alternatively can be given as a string
	    <userinput>"fit"</userinput> in which case,
	    the x range will be set precisely and the y range will be set with
	    five percent borders around the line.
    	  </para>
    	  <para lang="en">
	    Finally, legend should be a string that can be used as the legend in the
	    graph.  That is, if legends are being printed.
          </para>
	  <para lang="en">
	  Examples:
          <screen lang="en"><prompt>genius&gt;</prompt> <userinput>SurfacePlotDrawLine(0,0,0,1,1,1,"color","blue","thickness",3)</userinput>
<prompt>genius&gt;</prompt> <userinput>SurfacePlotDrawLine([0,0,0;1,-1,2;-1,-1,-3])</userinput>
</screen>
          </para>
	  <para lang="en">
		  Available from version 1.0.19 onwards.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-SurfacePlotDrawPoints"/>SurfacePlotDrawPoints</term>
         <listitem>
          <synopsis lang="en">SurfacePlotDrawPoints (x,y,z,...)</synopsis>
          <synopsis lang="en">SurfacePlotDrawPoints (v,...)</synopsis>
          <para lang="en">
		  Draw a point at <varname>x</varname>,<varname>y</varname>,<varname>z</varname>.
		  The input can be an <varname>n</varname> by 3 matrix
		  for <varname>n</varname> different points.  This function has essentially the same
		  input as <link linkend="gel-function-SurfacePlotDrawLine">SurfacePlotDrawLine</link>.
          </para>
          <para lang="en">
	    Extra parameters can be added to specify line color, thickness,
	    the plotting window, or legend.
	    You can do this by adding an argument string <userinput>"color"</userinput>, 
	    <userinput>"thickness"</userinput>,
	    <userinput>"window"</userinput>, 
	    or <userinput>"legend"</userinput>, and after it specify
	    the color, the thickness, the window
	    as 6-vector, or the legend.
    	  </para>
    	  <para lang="en">
	    The color should be either a string indicating the common English word for the color
	    that GTK will recognize such as 
            <userinput>"red"</userinput>, <userinput>"blue"</userinput>, <userinput>"yellow"</userinput>, etc...
	    Alternatively the color can be specified in RGB format as
	    <userinput>"#rgb"</userinput>, <userinput>"#rrggbb"</userinput>, or
	    <userinput>"#rrrrggggbbbb"</userinput>, 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.
    	  </para>
    	  <para lang="en">
	    The window should be given as usual as <userinput>[x1,x2,y1,y2,z1,z2]</userinput>, or
	    alternatively can be given as a string
	    <userinput>"fit"</userinput> in which case,
	    the x range will be set precisely and the y range will be set with
	    five percent borders around the line.
    	  </para>
    	  <para lang="en">
	    Finally, legend should be a string that can be used as the legend in the
	    graph.  That is, if legends are being printed.
          </para>
	  <para lang="en">
	  Examples:
          <screen lang="en"><prompt>genius&gt;</prompt> <userinput>SurfacePlotDrawPoints(0,0,0,"color","blue","thickness",3)</userinput>
<prompt>genius&gt;</prompt> <userinput>SurfacePlotDrawPoints([0,0,0;1,-1,2;-1,-1,1])</userinput>
</screen>
          </para>
	  <para lang="en">
		  Available from version 1.0.19 onwards.
	  </para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-VectorfieldClearSolutions"/>VectorfieldClearSolutions</term>
         <listitem>
          <synopsis lang="en">VectorfieldClearSolutions ()</synopsis>
          <para lang="en">
	    Clears the solutions drawn by the
	    <link linkend="gel-function-VectorfieldDrawSolution"><function>VectorfieldDrawSolution</function></link>
	    function.
          </para>
	  <para lang="en">Version 1.0.6 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-VectorfieldDrawSolution"/>VectorfieldDrawSolution</term>
         <listitem>
          <synopsis lang="en">VectorfieldDrawSolution (x, y, dt, tlen)</synopsis>
          <para lang="en">
	    When a vector field plot is active, draw a solution with
	    the specified initial condition.  The standard
	    Runge-Kutta method is used with increment <varname>dt</varname>
	    for an interval of length <varname>tlen</varname>.
	    Solutions stay on the graph until a different plot is shown or until
	    you call 
	    <link linkend="gel-function-VectorfieldClearSolutions"><function>VectorfieldClearSolutions</function></link>.
	    You can also use the graphical interface to draw solutions and specify
	    initial conditions with the mouse.
          </para>
	  <para lang="en">Version 1.0.6 onwards.</para>
         </listitem>
        </varlistentry>

        <varlistentry>
         <term lang="en"><anchor id="gel-function-VectorfieldPlot"/>VectorfieldPlot</term>
         <listitem>
          <synopsis lang="en">VectorfieldPlot (funcx, funcy)</synopsis>
          <synopsis lang="en">VectorfieldPlot (funcx, funcy, x1, x2, y1, y2)</synopsis>
          <para lang="en">
	    Plot a two dimensional vector field.  The function
	    <varname>funcx</varname>
	    should be the dx/dt of the vectorfield and the function
	    <varname>funcy</varname> should be the dy/dt of the vectorfield.
	    The functions
	    should take two real numbers <varname>x</varname>
	    and <varname>y</varname>, or a single complex
	    number.  When the parameter
	    <link linkend="gel-function-VectorfieldNormalized"><function>VectorfieldNormalized</function></link>
	    is <constant>true</constant>, then the magnitude of the vectors is normalized.  That is, only
	    the direction and not the magnitude is shown.
	  </para>
	  <para lang="en">
            Optionally you can specify the limits of the plotting window as
	    <varname>x1</varname>, <varname>x2</varname>,
	    <varname>y1</varname>, <varname>y2</varname>.  If limits are not
	    specified, then the currently set limits apply
	    (See <link linkend="gel-function-LinePlotWindow"><function>LinePlotWindow</function></link>).
          </para>
          <para lang="en">
	    The parameter
	    <link linkend="gel-function-LinePlotDrawLegends"><function>LinePlotDrawLegends</function></link>
	    controls the drawing of the legend.
	  </para>
          <para lang="en">
	    Examples:
          <screen lang="en"><prompt>genius&gt;</prompt> <userinput>VectorfieldPlot(`(x,y)=x^2-y, `(x,y)=y^2-x, -1, 1, -1, 1)</userinput>
</screen>
          </para>
         </listitem>
        </varlistentry>

      </variablelist>
    </sect1>

  </chapter>

  <!-- ============= GEL examples ============================= -->
  <chapter id="genius-gel-example-programs">
    <title>Примеры программ на GEL</title>

    <para lang="en">
Here is a function that calculates factorials:
<programlisting lang="en"><![CDATA[function f(x) = if x <= 1 then 1 else (f(x-1)*x)
]]></programlisting>
    </para>
    <para lang="en">
With indentation it becomes:
<programlisting lang="en"><![CDATA[function f(x) = (
  if x <= 1 then
    1
  else
    (f(x-1)*x)
)
]]></programlisting>
    </para>
    <para lang="en">
This is a direct port of the factorial function from the <application>bc</application> manpage. The syntax seems similar to <application>bc</application>, but different in that in GEL, the last expression is the one that is returned. Using the <literal>return</literal> function instead, it would be:
<programlisting lang="en"><![CDATA[function f(x) = (
  if (x <= 1) then return (1);
  return (f(x-1) * x)
)
]]></programlisting>
    </para>

    <para lang="en">
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.
<programlisting lang="en">function f(x) = prod k=1 to x do k
</programlisting>
    </para>

    <para lang="en">
Here is a larger example, this basically redefines the internal
<link linkend="gel-function-ref"><function>ref</function></link> function to calculate the row echelon form of a
matrix.  The function <function>ref</function> is built in and much faster,
but this example demonstrates some of the more complex features of GEL.
<programlisting lang="en"><![CDATA[# 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
)
]]></programlisting>
    </para>

  </chapter>

  <!-- ============= Customization ============================ -->
  <chapter id="genius-prefs"> 
    <title>Настройки</title> 

    <para lang="en">
      To configure <application>Genius Mathematics Tool</application>, choose
      <menuchoice><guimenu>Settings</guimenu>
      <guimenuitem>Preferences</guimenuitem></menuchoice>.
      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.
    </para>

    <note>
      <title lang="en">Changing Settings with GEL</title>
      <para lang="en">
	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
	<xref linkend="genius-gel-variables"/> about evaluating and assigning
	to variables, and <xref linkend="genius-gel-function-parameters"/> for
	a list of settings that can be modified in this way.
      </para>
      <para lang="en">
As an example, you can set the maximum number of digits in a result to 12 by typing:
<programlisting lang="en">MaxDigits = 12
</programlisting>
      </para>
    </note>

    <sect1 id="genius-prefs-output"> 
      <title lang="en">Output</title> 
      <variablelist> 
	<varlistentry>
	  <term lang="en"> 
	    <guilabel>Maximum digits to output</guilabel>
      </term> 
	  <listitem>
		  <para lang="en">The maximum digits in a result (<link linkend="gel-function-MaxDigits"><function>MaxDigits</function></link>)</para>
	  </listitem>
	</varlistentry>
	<varlistentry>
	  <term lang="en"> 
	    <guilabel>Results as floats</guilabel>
      </term> 
	  <listitem>
		  <para lang="en">If the results should be always printed as floats (<link linkend="gel-function-ResultsAsFloats"><function>ResultsAsFloats</function></link>)</para>
	  </listitem>
	</varlistentry>
	<varlistentry>
	  <term lang="en"> 
	    <guilabel>Floats in scientific notation</guilabel>
      </term> 
	  <listitem>
		  <para lang="en">If floats should be in scientific notation (<link linkend="gel-function-ScientificNotation"><function>ScientificNotation</function></link>)</para>
	  </listitem>
	</varlistentry>
	<varlistentry>
	  <term lang="en"> 
	    <guilabel>Always print full expressions</guilabel>
      </term> 
	  <listitem>
		  <para lang="en">Should we print out full expressions for non-numeric return values (longer than a line) (<link linkend="gel-function-FullExpressions"><function>FullExpressions</function></link>)</para>
	  </listitem>
	</varlistentry>

	<varlistentry>
	  <term lang="en"> 
	    <guilabel>Use mixed fractions</guilabel>
      </term> 
	  <listitem>
		  <para lang="en">If fractions should be printed as mixed fractions such as "1 1/3" rather than "4/3". (<link linkend="gel-function-MixedFractions"><function>MixedFractions</function></link>)</para>
	  </listitem>
	</varlistentry>

	<varlistentry>
	  <term lang="en"> 
	    <guilabel>Display 0.0 when floating point number is less than 10^-x (0=never chop)</guilabel>
      </term> 
	  <listitem>
	  <para lang="en">How to chop output.  But only when other numbers nearby are large.
	   See the documentation of the parameter
          <link linkend="gel-function-OutputChopExponent"><function>OutputChopExponent</function></link>. </para>
	  </listitem>
	</varlistentry>

	<varlistentry>
	  <term lang="en"> 
            <guilabel>Only chop numbers when another number is greater than 10^-x</guilabel>
      </term> 
	  <listitem>
		  <para lang="en">When to chop output.  This is set by the parameter <link linkend="gel-function-OutputChopWhenExponent"><function>OutputChopWhenExponent</function></link>.
	   See the documentation of the parameter
          <link linkend="gel-function-OutputChopExponent"><function>OutputChopExponent</function></link>. </para>
	  </listitem>
	</varlistentry>

	<varlistentry>
	  <term lang="en"> 
	    <guilabel>Remember output settings across sessions</guilabel>
      </term> 
	  <listitem>
        <para lang="en">Should the output settings in the <guilabel>Number/Expression output options</guilabel> frame
	      be remembered for next session.  Does not apply to the <guilabel>Error/Info output options</guilabel> frame.</para>
	      <para lang="en">
		 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 <application>Genius Mathematics Tool</application> and then uncheck it again.
	      </para>
	  </listitem>
	</varlistentry>

	<varlistentry>
	  <term lang="en"> 
	    <guilabel>Display errors in a dialog</guilabel>
      </term> 
	  <listitem>
        <para lang="en">If set the errors will be displayed in a separate dialog, if
	unset the errors will be printed on the console.</para>
	  </listitem>
	</varlistentry>

	<varlistentry>
	  <term lang="en"> 
	    <guilabel>Display information messages in a dialog</guilabel>
      </term> 
	  <listitem>
	<para lang="en">If set the information messages will be displayed in a separate
	dialog, if unset the information messages will be printed on the
	console.</para>
	  </listitem>
	</varlistentry>

	<varlistentry>
	  <term lang="en"> 
	    <guilabel>Maximum errors to display</guilabel>
      </term> 
	  <listitem>
        <para lang="en">
	  The maximum number of errors to return on one evaluation
	  (<link linkend="gel-function-MaxErrors"><function>MaxErrors</function></link>).  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.
	  </para>
	  </listitem>
	</varlistentry>
      </variablelist> 

      <para lang="en">
	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 <xref linkend="genius-gel-function-parameters"/>.
      </para>

      <variablelist> 
	<varlistentry>
	  <term lang="en"> 
	    <function>IntegerOutputBase</function>
      </term> 
	  <listitem>
        <para lang="en">The base that will be used to output integers</para>
	  </listitem>
	</varlistentry>

	<varlistentry>
	  <term lang="en"> 
	    <function>OutputStyle</function>
      </term> 
	  <listitem>
	<para lang="en">A string, can be <literal>"normal"</literal>,
<literal>"latex"</literal>, <literal>"mathml"</literal> or
<literal>"troff"</literal> 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 <application>Genius Mathematics Tool</application>.  The other styles are for
typesetting in LaTeX, MathML (XML), or in Troff.</para>
	  </listitem>
	</varlistentry>
      </variablelist> 
   </sect1> 

    <sect1 id="genius-prefs-precision"> 
      <title lang="en">Precision</title> 
      <variablelist> 
	<varlistentry>
	  <term lang="en"> 
	    <guilabel>Floating point precision</guilabel>
      </term> 
	  <listitem>
        <para lang="en">
	  The floating point precision in bits
	  (<link linkend="gel-function-FloatPrecision"><function>FloatPrecision</function></link>).
	  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 <link linkend="gel-function-pi"><function>pi</function></link> or
	  <link linkend="gel-function-e"><function>e</function></link>.
	  </para>
	  </listitem>
	</varlistentry>

	<varlistentry>
	  <term lang="en"> 
	    <guilabel>Remember precision setting across sessions</guilabel>
      </term> 
	  <listitem>
        <para lang="en">
	   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.
	  </para>
	  </listitem>
	</varlistentry>
      </variablelist> 
    </sect1> 

    <sect1 id="genius-prefs-terminal"> 
      <title>Терминал</title> 

      <para>Терминалом называется консоль в рабочей области.</para>

      <variablelist> 
	<varlistentry>
	  <term lang="en"> 
	    <guilabel>Scrollback lines</guilabel>
      </term> 
	  <listitem>
        <para lang="en">Lines of scrollback in the terminal.</para>
	  </listitem>
	</varlistentry>
	<varlistentry>
	  <term lang="en"> 
	    <guilabel>Font</guilabel>
      </term> 
	  <listitem>
        <para>Шрифт, используемый в терминале</para>
	  </listitem>
	</varlistentry>
	<varlistentry>
	  <term lang="en"> 
	    <guilabel>Black on white</guilabel>
      </term> 
	  <listitem>
        <para>Использовать в терминале чёрный текст на белом фоне.</para>
	  </listitem>
	</varlistentry>
	<varlistentry>
	  <term lang="en"> 
	    <guilabel>Blinking cursor</guilabel>
      </term> 
	  <listitem>
        <para>Должен ли курсор терминала мигать, если фокус ввода находится в терминале. Иногда это раздражает, кроме того это создаёт лишний трафик при удалённом доступе к Genius.</para>
	  </listitem>
	</varlistentry>
      </variablelist> 
    </sect1> 

    <sect1 id="genius-prefs-memory"> 
      <title>Память</title> 
      <variablelist> 
	<varlistentry>
	  <term lang="en"> 
	    <guilabel>Maximum number of nodes to allocate</guilabel>
      </term> 
	  <listitem>
        <para lang="en">
	   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.
	  </para>
        <para lang="en">
	   Once the limit is reached, <application>Genius Mathematics Tool</application> 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.
        </para>
        <para lang="en">
	   Setting the limit to zero means there is no limit to the amount of
	   memory that genius uses.
        </para>
	  </listitem>
	</varlistentry>

      </variablelist> 
    </sect1> 

  </chapter>

<!-- ============= About ====================================== -->
  <chapter id="genius-about"> 
    <title>О <application>математическом инструменте Genius</application></title> 

    <para><application>Математический инструмент Genius</application> создан Jiří (George) Lebl (<email>jirka@5z.com</email>). История <application>математического инструмента Genius</application> началась в конце 1997 г. Это был первый калькулятор для GNOME, но с тех пор он вырос в нечто большее, чем простой настольный калькулятор. Чтобы узнать больше о <application>математическом инструменте Genius</application>, посетите <ulink url="http://www.jirka.org/genius.html" type="http">веб-страницу Genius</ulink>.</para>
    <para lang="en">
      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).
    </para>

    <para lang="en"> 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
      <ulink url="http://www.gnu.org/copyleft/gpl.html" type="http">link</ulink>, or in the file
      COPYING included with the source code of this program. </para>

    <para lang="en">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.</para>

  </chapter>

</book>
