Příručka k matematickému nástroji Genius.

# Příručka k aplikaci Genius

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

Je povoleno kopírovat, šířit a/nebo upravovat tento dokument za podmínek GNU Free Documentation License (GFDL) ve verzi 1.1 nebo v jakékoli další verzi vydané nadací Free Software Foundation; bez neměnných oddílů, bez textů předních desek a bez textů zadních desek. Kopii licence GFDL naleznete pod tímto odkazem nebo v souboru COPYING-DOCS dodávaném s touto příručkou.

Tato příručka je součástí sbírky příruček GNOME šířených za podmínek licence GFDL. Pokud chcete tento dokument šířit odděleně od sbírky, musíte přiložit kopii licence dle popisu v oddílu 6 dané licence.

Mnoho názvů použitých firmami k zviditelnění produktů nebo služeb jsou ochranné známky. Na místech, kde jsou tyto názvy v dokumentaci použity a členové Dokumentačního projektu GNOME jsou si vědomi skutečnosti, že se jedná o ochrannou známku, je takovýto název psán velkými písmeny celý nebo s velkým písmenem na začátku.

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

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

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

Jiří Lebl
Oklahoma State University

     jiri.lebl@gmail.com

Kai Willadsen
University of Queensland, Australia

     kaiw@itee.uq.edu.au

0.3
March 2026

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

This manual describes version 1.0.29 of Genius.

Ohlasy

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

## Úvod

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

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

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

Obecně, pokud se jedná o vlastnost jazyka (funkci, operátor apod.) jako novinku od verze 1.0.5, je to zmíněno, ale ohledně starších verzí než 1.0.5 byste se měli podívat do souboru NEWS.

## Začínáme

### Jak spustit matematický nástroj Genius

Matematický nástroj Genius můžete spustit následujícími způsoby:

Nabídka Aplikace

  V závislosti na vašem operačním systému a jeho verzi se může položka nabídky Matematický nástroj Genius vyskytovat na různých místech. Může být v podnabídkách Vzdělávání, Příslušenství, Kancelář, Věda nebo podobných, záleží na vašem konkrétním nastavení. Název položky, kterou hledáte je Matematický nástroj Genius. Až položku v nabídce naleznete, klikněte na ni a tím matematický nástroj Genius spustíte.

Dialogové okno Spustit aplikaci

  Položka nabídky nemusí být v závislosti na instalaci vašeho systému dostupná. Pokud se tak stane, můžete otevřít dialogové okno Spustit aplikaci a spustit `gnome-genius`.

Příkazový řádek

  Pro spuštění Matematického nástroje Genius ve verzi pro GNOME spusťte z příkazového řádku `gnome-genius`.

  Pokud chcete spustit jen verzi pro příkazový řádek, spusťte následující příkaz: `genius`. Tato verze nezahrnuje grafické prostředí a některá funkcionalita, jako kreslení, nebude dostupná.

### Když spustíte aplikaci Genius

Když spustíte matematický nástroj Genius ve vydání GNOME, zobrazí se okno jako je na obrázku .

Okno Matematického nástroje Genius

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

Okno Matematického nástroje Genius obsahuje následující prvky:

Lišta nabídek

  Nabídky v liště nabídek obsahují všechny příkazy, které potřebujete pro práci se soubory v Matematickém nástroji Genius. Nabídka Soubor obsahuje položky pro načítání a ukládání položek a vytváření nových programů. Příkaz Načíst a spustit… neotevírá nové okno pro program, ale program jen přímo spustí. To je to stejné, co dělá příkaz `load`.

  Nabídka Kalkulátor ovládá výpočetní jádro. Umožňuje vám spustit právě vybraný program nebo přerušit právě probíhající výpočet. Můžete také hledat v úplných výrazech poslední odpovědi (to je užitečné, když je poslední odpověď delší, než se vloze do jedné obrazovky konzoly) nebo si zobrazovat seznam hodnot všech uživatelem definovaných proměnných. Rovněž můžete sledovat uživatelské proměnné, což se hodí hlavně, když běží dlouhý výpočet nebo některý program ladíte. A nakonec poskytuje kreslící funkce přes uživatelsky přívětivé dialogové okno.

  Pod nabídkou Příklady je seznam příkladů a ukázkových programů. Když nabídku otevřete, načte se příklad jako nový program, který můžete spouštět, upravovat, měnit a ukládat. Tyto programy by měly být dobře zdokumentované a obecně předvádět některé z vlastností matematického nástroje Genius nebo nějaký matematický koncept.

  Pod nabídkou Programy je seznam právě otevřených programů a umožňuje mezi nimi přepínat.

  Ostatní nabídky mají funkce podobné jako v jiných aplikacích.

Lišta nástrojů

  Lišta nástrojů obsahuje podmnožinu příkazů, které jsou dostupné z lišty nabídek.

Pracovní oblast

  Pracovní oblast je hlavní způsob, jak s aplikací komunikovat.

  Na začátku má pracovní oblast jedinou kartu Konzola, která je hlavním způsobem, jak komunikovat s kalkulátorem. V ní zapisujete výrazy a po zmáčknutí klávesy Enter jsou v ní hned vraceny výsledky.

  Případně můžete psát delší programy a ty se pak mohou objevit v samostatných kartách. Programy jsou sady příkazů nebo funkcí, které mohou být spuštěny naráz jako jeden celek, aniž byste je museli postupně zadávat do příkazkového řádku. Programy mohou být uloženy do souborů pro pozdější opětovné použití.

## Základy používání

### Používání pracovní oblasti

Normálně s kalkulátorem komunikujete na kartě Konzola v pracovní oblasti. Pokud spustíte pouze textovou verzi, je konzola jediná dostupná věc. Jestli chcete používat matematický nástroj Genius pouze jako kalkulačku, jednoduše napište výraz do konzoly. Bude vyhodnocen a vrácený výsledek vypsán.

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

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

or

    genius> 62734 + 812634 + 77^4 mod 5

or

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

or

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

(Last is the harmonic sum from 1 to 70)

To get a list of functions and commands, type:

    genius> help

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

    genius> help FunctionName

To view this manual, type:

    genius> manual

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

    genius> load path/to/program.gel

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

### Jak vytvořit nový program

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

Když chcete začít psát nový program, zvolte Soubor Nový program a v pracovní oblasti se objeví nová karta. V té můžete nový program v jazyce GEL psát. Až jej dopíšete, můžete jej spustit pomocí Kalkulátor Spustit (nebo tlačítkem Spustit na nástrojové liště). Tím se váš program provede a na kartě Konzola zobrazí výstup. Ve výsledku je to stejné, jako byste vzali text celého programu a napsali jej do konzoly. Jediný rozdíl je v tom, že vstup je proveden nezávisle na konzole, zatímco výstup jde na konzolu. Kalkulátor Spustit vždy spustí aktuálně vybraný program, i když jste zrovna na kartě Konzola. Aktuálně vybraný program má svoji kartu označenou tučným písmem a vybere se tak, že na kartu prostě kliknete.

Abyste napsaný program uložili, zvolte Soubor Uložit jako… Podobně, jako v jiných aplikacích, můžete zvolit Soubor Uložit pro uložení programu, který již má přidělený název souboru. V případě, že máte otevřených hodně programů, které upravujete, a přejete si je uložit, můžete zvolit také Soubor Uložit neuložené.

Programy, ve kterých jsou neuložené změny, mají vedle svého názvu souboru „[+]“. Díky tomu můžete rychle poznat, jestli se soubor na disku a otevřený v kartě odlišují. Programy, které zatím nemají přidělený název souboru, jsou stále považovány za neuložené a „[+]“ se u nich nevypisuje.

### Jak otevřít a spustit program

Když chcete otevřít soubor, zvolte Soubor Otevřít. V pracovní oblasti se objeví nová karta obsahující daný soubor. Můžete ji využít k upravě souboru.

Pro spuštění programu ze souboru zvolte Soubor Načíst a spustit… Tím se program spustí, aniž by se otevírala zvláštní karta. To odpovídá chování příkazu `load`.

Pokud jste v souboru provedli úpravy, které si přejte zahodit a načíst znovu původní verzi z disku, můžete zvolit položku nabídky Soubor Znovu načíst z disku. To se hodí při experimentování s programem a při provádění dočasných změn, kdy chcete spustit upravený program, ale změny nechcete uchovat.

## Vykreslování

Vykreslování je podporováno pouze ve v grafické verzi GNOME. Veškeré vykreslování je přístupné z grafického rozhraní, ke kterému se dostanete z okna Vytvoření grafu. K tomuto oknu se dostanete kliknutím na tlačítko Graf na liště nástrojů nebo výběrem Vykrestlit

### Čárové grafy

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

Když kliknete na tlačítko Vykreslit, otevře se okno s několika kartami. Musíte být na kartě Čárový graf funkce a v ní na kartě Funkce/výrazy. Viz .

Okno Vytváření grafu

Shows the line plotting window.

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

Proměnné lze přejmenovat kliknutím na tlačítko Změnit názvy proměnných…, což se hodí, když chcete vytisknout nebo uložit obrázek a nechcete použít standardní názvy. Nakonec můžete také úplně zakázat tisk legendy a popisů os, což se opět hodí při tisku nebo ukládání, když by tyto texty způsobovaly nepřehlednost.

Okno s grafem

The graph produced.

Z tohoto místa můžete graf vytisknout, vytvořit z něj dokument ve formátu uzavřený postskript nebo PNG a nebo změnit zvětšení. Pokud není závislá osa správně nastavena, můžete Genius přimět, aby ji přizpůsobil pomocí nalezení extrému vykreslené funkce.

Ohledně kreslení pomocí příkazového řádku se podívejte do dokumentace na funkci `LinePlot`.

### Parametrické grafy

Na kartě vytváření grafu můžete zvolit také kartu Parametrické, pomocí které můžete vytvářet dvourozměrné parametrické grafy. Jde o způsob, jak vykreslit jednoduchou parametrickou funkci. Můžete zadat také body jako `x` a `y` nebo poskytnout jedno komplexní číslo jako funkci proměnné `t`. Rozsah proměnné `t` je dán explicitně a funkce je vzorkována v zadaných krocích. Rozsah `x` a `y` může být zvolen automaticky zaškrtnutím políčka Přizpůsobit závislou osu nebo může být určen explicitně. Viz .

Karta parametrických grafů

Parametric plotting tab in the Create Plot window.

Příklad parametrického grafu je uveden na obrázku . Dělat můžete podobné operace jako u jiných čárových grafů. Na to, jak vykreslení provést z příkazového řádku, se podívejte do dokumentace na funkci `LinePlotParametric` nebo `LinePlotCParametric`.

Parametrické grafy

Parametric plot produced

### Grafy směrových polí

Na kartě vytváření grafu můžete zvolit také kartu Směrové pole, pomocí které můžete vytvářet dvourozměrný graf směrového pole. Dělat můžete podobné operace jako u jiných čárových grafů. Na to, jak vykreslení provést z příkazového řádku, se podívejte do dokumentace na funkci `SlopefieldPlot`.

Když je aktivováno směrové pole, je přístupná dodatečná nabídka Řešitel, přes kterou můžete zobrazit dialogové okno řešitele. Zde můžete Genius přimět vykreslit konkrétní řešení pro zadané počáteční podmínky. Buď můžete počáteční podmínky zadat v dialogovém okně nebo kliknout přímo do grafu a tím určit počáteční bod. Dokud je dialogové okno řešitele aktivní, nefunguje zvětšování/zmenšování kliknutím a tažením. Pokud chcete měnit velikost pomocí myši, musíte dialogové okno nejdříve zavřít.

Řešitel používá standardní Rungeho-Kuttovu metodu. Grafy na obrazovce zůstávají, dokud nejsou vymazány. Řešitel se zastaví vždy, když dosáhne hranice okna s grafem. Změnou velikosti omezení nebo parametru se řešení nemění, musíte graf vymazat a znovu vykreslit se správnými parametry. Můžete také využít funkci `SlopefieldDrawSolution` k vykreslení řešení z příkazového řádku nebo programu.

### Grafy vektorových polí

Na kartě vytváření grafu můžete zvolit také kartu Vektorové pole, pomocí které můžete vytvářet dvourozměrný graf vektorového pole. Dělat můžete podobné operace jako u jiných čárových grafů. Na to, jak vykreslení provést z příkazového řádku, se podívejte do dokumentace na funkci `VectorfieldPlot`.

Standardně je zobrazen směr a velikost vektorového pole. Pokud chcete zobrazovat jen směr a velikost ne, zaškrtněte příslušné políčko a délka šipek se sjednotí.

Když je aktivováno vektorové pole, je přístupná dodatečná nabídka Řešitel, přes kterou můžete zobrazit dialogové okno řešitele. Zde můžete Genius přimět vykreslit konkrétní řešení pro zadané počáteční podmínky. Buď můžete počáteční podmínky zadat v dialogovém okně nebo kliknout přímo do grafu a tím určit počáteční bod. Dokud je dialogové okno řešitele aktivní, nefunguje zvětšování/zmenšování kliknutím a tažením. Pokud chcete měnit velikost pomocí myši, musíte dialogové okno nejdříve zavřít.

Řešitel používá standardní Rungeho-Kuttovu metodu. Grafy na obrazovce zůstávají, dokud nejsou vymazány. Změnou velikosti omezení nebo parametru se řešení nemění, musíte graf vymazat a znovu vykreslit se správnými parametry. Můžete také využít funkci `VectorfieldDrawSolution` k vykreslení řešení z příkazového řádku nebo programu.

### Plošné grafy

Genius umí vykreslovat i plochy. Vyberte kartu Plošný graf v hlavním sešitu okna Vytváření grafu. Zde můžete zadat jeden výraz, který by měl používat buď `x` a `y` jako reálné nezávislé proměnné nebo `z` jako komplexní proměnnou (kde `x` je reálné část `z` a `y` jeho imaginární část). Například pro vykreslení absolutní hodnoty funkce kosinus pro komplexní parametry, můžete zadat `|cos(z)|`. To je ekvivalentní k `|cos(x+1i*y)|`. Viz . Na to, jak vykreslení provést z příkazového řádku, se podívejte do dokumentace na funkci `SurfacePlot`.

Rozsah `z` může být nastaven automaticky zapnutím zaškrtávacího políčka Přizpůsobit závislou osu. Proměnné mohou být přejmenovány kliknutím na tlačítko Změnit názvy proměnných…, což se hodí, když chcete vytisknout nebo uložit obrázek a nechcete na něm použít standardní názvy. Nakonec můžete zakázat tisk legendy, což se opět hodí při tisku a ukládání, když by legenda způsobovala nepřehlednost.

Plošný graf

Modulus of the complex cosine function.

V režimu plošných grafů levá a pravá šipka na klávesnici otáčí zobrazení okolo osy z. Případně můžete otáčet kolem libovolné osy pomocí Otočit osu… v nabídce Zobrazit. Nabídka Zobrazit obsahuje také režim pohledu shora, který otáčí graf tak, že osa z směřuje ven, tj. díváte se na graf shora a dostanete základní barvy, které definují hodnoty funkce získávající teplotní graf funkce. Nakonec byste také měli zkusit Spustit animované otáčení…, které spustí plynulé pomalé otáčení. To je dobré hlavně na předvádění matematického nástroje Genius publiku.

## Základy jazyka GEL

GEL znamená Genius Extension Language (rozšiřující jazyk Genius). Jedná se o jazyk, ve kterém píšete programy v kalkulátoru Genius. Program v jazyce GEL je jednoduše výraz, který je vyhodnocen jako číslo, matice nebo nějaký jiný objekt v GEL. Matematický nástroj Genius tak může sloužit jako jednoduchý kalkulátor a nebo jako mocný nástroj pro teoretický vědecký výzkum. Cílem syntaxe je, aby byla snadná na naučení, jak jen to jde, zejména pro používání aplikace jako kalkulačky.

### Hodnoty

Hodnotami v jazyce GEL mohou být čísla, pravdivostní hodnoty nebo řetězce. GEL zachází jako s hodnotami i s maticemi. Hodnoty mohou být mimo jiných věcí použity k výpočtům, přiřazovány do proměnných a vraceny z funkcí.

#### Čísla

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

    1234

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

    0x123ABC
    01234

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

    23\1234ABCD

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

    3/4

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

    1 3/10

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

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

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

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

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

Při zadávání imaginárních čísel musí číslo vždy předcházet před `i`. Pokud byste použili samotné `i`, Genius by se k němu stavěl, jako k odkazu na proměnnou `i`. Pokud potřebujete použít právě `i`, použijte místo toho `1i`.

Pokud chcete u imaginárních čísel použít notaci složených zlomků, musíte složený zlomek uzavřít do závorek, např. `(1 2/5)i`.

#### Pravdivostní hodnoty

Genius také nativně podporuje pravdivostní hodnoty (boolean). Jsou definovány dvě pravdivostní konstanty, `true` (pravda) a `false` (nepravda). Tyto identifikátory mohou být použity stejně jako jiné proměnné. Případně můžete použít i varianty `True`, `TRUE`, `False` a `FALSE`.

Všude, kde je očekáván pravdivostní výraz, můžete použít pravdivostní hodnotu nebo libovolný výraz, jehož výsledkem je číslo nebo pravdivostní hodnota. V případě, že má Genius vyhodnotit číslo jako pravdivostní hodnotu, pak je nula brána jako `false` a všechna ostatní čísla jako `true`.

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

    ( (1 + true) - false ) * true

is the same as:

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

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

    1 == true

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

#### Řetězce

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

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

will create the string:

    The result is: 5

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

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

will make a string:

    Slash: \ Quotes: " Tabs: 	1	2	3

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

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

    string(22)

will return

    "22"

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

#### Null

Existuje speciální hodnota nazývaná `null`. Nelze s ní provádět žádné operace a když je vrácena, není nic vypsáno. Proto je hodnota `null` užitečná, když nechcete z výrazu získat žádný výstup. Hodnotu `null` získáte tak, že napíšete výraz `.`, konstantu `null` nebo nic. Tím se nemyslí nic jiného, než že když výraz zakončíte oddělovačem `;`, je to stejné, jako byste jej zakončili oddělovačem následovaným `null`.

Example:

    x=5;.
    x=5;

Některé funkce vrací `null` v případě, že nelze vrátit žádnou hodnotu nebo nastane chyba. `null` se rovněž používá jako prázdný vektor, prázdná matice nebo prázdná reference (odkaz).

### Používání proměnných

Syntax:

    VariableName

Example:

    genius> e
    = 2.71828182846

Pro vyhodnocení proměnné jako takové jednoduše napište její název. Bude vrácena hodnota proměnné. Proměnnou můžete použít kdekoliv, kde by se normálně použilo číslo nebo řetězec. Navíc jsou proměnné nutné při definici funkcí, které vyžadují argumenty (viz ).

Dokončování pomocí Tab

Můžete používat klávesu Tab, aby vám Genius dokončoval názvy proměnných. Zkuste napsat prvních pár písmen názvu a zmáčknout `Tab`.

Názvy proměnných rozlišují velikost písmen

U názvů proměnných se rozlišuje velikost písmen. To znamená, že proměnné `ahoj`, `AHOJ` a `Ahoj` jsou různé.

#### Nastavování proměnných

Syntax:

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

Example:

    x = 3
    x := 3

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

    a = b = 5

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

Pro nastavení proměnné lze použít jak operátor `=`, tak `:=`. Rozdíl mezi nimi je v tom, že operátor `:=` vždy vystupuje jako operátor přiřazení, zatímco operátor `=` může být interpretován jako test rovnosti, jestliže je použit v místě, kde je očekáván pravdivostní výraz.

Ohledně více informací o rozsahu působnosti proměnných, čímž je míněno, kdy je která proměnná viditelná, se podívejte na kapitolu .

#### Vestavěné proměnné

Jazyk GEL má několik vestavěných „proměnných“, jako třeba `e`, `pi` nebo `GoldenRatio`. Jedná se o široce používané konstanty s příslušnými hodnotami, do kterých nelze přiřadit nové hodnoty. Těchto vestavěných proměnných je celá řada, viz pro kompletní seznam. Upozorňujeme, že `i` není standardně definována jako druhá odmocnina z mínus jedné (imaginární číslo) a ve výchozím stavu je nedefinovaná, takže ji můžete používat jako počítadlo, jak je zvykem. Když chcete zapsat imaginární číslo, musíte použít `1i`.

#### Proměnná s posledním výsledkem

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

    Ans+389

### Používání funkcí

Syntax:

    FunctionName(argument1, argument2, ...)

Example:

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

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

Existuje množství zabudovaných funkcí, jako třeba `sin`, `cos` a `tan`. Můžete použít zabudovanou funkci `help` k výpisu dostupných funkcí nebo si přečíst kapitolu .

Dokončování pomocí Tab

Můžete používat klávesu Tab, aby vám Genius dokončoval názvy funkcí. Zkuste napsat prvních pár písmen názvu a zmáčknout `Tab`.

Názvy funkcí rozlišují velikost písmen

U názvů funkcí se rozlišuje velikost písmen. To znamená, že funkce pojmenované `necoudelat`, `NECOUDELAT` a `NecoUdelat` jsou rozdílné funkce.

#### Definování funkcí

Syntax:

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

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

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

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

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

#### Proměnný seznam argumentů

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

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

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

#### Předávání funkcí funkcím

V aplikaci Genius je možné předat funkci jako argument jiné funkci. To lze udělat buď pomocí „uzlů funkcí“ nebo anonymních funkcí.

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

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

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

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

Example:

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

This will return 5.

#### Operace s funkcemi

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

    exp(sin*cos+4)

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

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

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

    f = exp(sin*cos+4)

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

    LinePlot(sin^2)

Ne všechny funkce je možné použít tímto způsobem. Například, pokud použijete binární operaci, musí funkce přebírat stejný počet argumentů.

### Oddělovač

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

    3 ; 5

This expression will yield 5.

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

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

### Komentáře

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

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

### Modulární aritmetika

Genius má implementovánu modulární aritmetiku. Když ji chcete použít, stačí přidat „mod <celé_číslo>“ za výraz. Například: `2^(5!) * 3^(6!) mod 5` Pro modulární aritmetiku by bylo možné použít i počítání s celými čísly a následně určením zbytku na konci pomocí operátoru `%`, ale to je časově náročné, ne-li nemožné, při práci s většími čísly. Například `10^(10^10) % 6` jednoduše nebude pracovat (exponent bude příliš velký), zatímco `10^(10^10) mod 6` je spočteno v mžiku. V prvním příkladu se zkusí vypočítat `10^(10^10)` a pak najít zbytek po dělení 6, zatímco v druhém příkladu se vyhodnotí vše modulo 6 už na začátku.

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

    10^-1 mod 101
    1/10 mod 101

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

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

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

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

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

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

Nezřetězujte operátory mod, umístěte jen jeden na konce výpočtu a všechny početní operace ve výrazu nalevo budou ošetřeny v modulární aritmetice. Když umístíte mod do mod, obdržíte neočekávané výsledky. Pokud chcete použít modulo na jediné číslo a jen zjistit, zda zůstane zbytek, je lepší použít operátor `%`. Když potřebujete zřetězit několik výrazů v modulární aritmetice s různými děliteli, může být lepší rozdělit výraz na více výrazů a použít dočasné proměnné, aby se předešlo vložení mod do mod.

### Seznam operátorů GEL

Vše v jazyce GEL jsou ve skutečnosti jen výrazy. Výrazy jsou dohromady řetězeny pomocí různých operátorů. Jak jste již viděli, i oddělovač je ve skutečnosti jen binární operátor jazyka. Zde je seznam operátorů jazyka GEL.

`a;b`

  Oddělovač, který vyhodnocuje jak `a`, tak `b`, ale vrací výsledek pouze z `b`.

`a=b`

  Operátor přiřazení.

`a:=b`

  Operátor přiřazení. Přiřadí `b` do `a` (`a` musí být platná l-hodnota). Liší se od `=`, protože se nikdy nepřevádí na `==`.

`|a|`

  Absolutní hodnota. V případě, že výraz je komplexní číslo, je vrácen modul (absolutní hodnota komplexního čísla, někdy také nazýván norma), což je vzdálenost od počátku. Například: `|3 * e^(1i*pi)|` vrátí 3.

  Více informací najdete v encyklopediích Mathworld (text je v angličtině) a Wikipedia.

`a^b`

  Umocnění, umocní `a` na `b`-tou.

`a.^b`

  Umocňování prvek po prvku. Umocní každý prvek matice `a` na `b`-tou. Nebo, když je `b` matice stejné velikosti jako `a`, umocňuje se prvek po prvku. Pokud je `a` číslo a `b` je matice, pak se vytvoří matice stejné velikosti jako `b` s `a` umocněným na všechny různé mocnitele v `b`.

`a+b`

  Sčítání. Sečte dvě čísla, matice, funkce nebo řetězce. Pokud přičtete řetězec k čemukoliv, výsledkem bude vždy řetězec. Pokud je jeden operand čtvercová matice a druhý číslo, je číslo vynásobeno jednotkovou maticí.

`a-b`

  Odčítání. Odečte dvě čísla, matice nebo funkce.

`a*b`

  Násobení. Jedná se o normální násobení matic.

`a.*b`

  Násobení prvek po prvku v situaci, kdy `a` a `b` jsou matice.

`a/b`

  Dělení. Pokud jsou `a` a `b` čísla, jedná se o běžné dělení. Pokud to jsou matice, odpovídá to `a*b^-1`.

`a./b`

  Dělení prvek po prvku. Pro čísla je to stejné jako `a/b`, ale u matic to funguje prvek po prvku.

`a\b`

  Zpětné dělení. Je to to stejné, jako `b/a`.

`a.\b`

  Zpětné dělení prvků prvky.

`a%b`

  Operátor zbytku. Nepřepíná do režimu modulární aritmetiky, ale jen prostě vrátí zbytek celočíselného dělení `a/b`.

`a.%b`

  Operátor zbytku dělení prvků prvky. Vrací zbytky po dělení celočíselných prvků celočíselnými prvky `a./b`.

`a mod b`

  Operátor modulární aritmetiky. Výraz `a` je vyhodnocen modulární aritmetikou vůči `b`. Viz . Některé funkce a operátory se chovají odlišně při modulární aritmetice s celými čísly.

`a!`

  Operátor faktoriálu. Je to jako `1*…*(n-2)*(n-1)*n`.

`a!!`

  Operátor dvojitého faktoriálu. Je to jako `1*…*(n-4)*(n-2)*n`.

`a==b`

  Operátor rovnosti, vrací `true` (pravda) nebo `false` (nepravda) podle toho, zda `a` je `b` rovno nebo není rovno.

`a!=b`

  Operátor nerovnosti, vrací `true` (pravda) v případě, že `a` se nerovná `b`, jinak vrací `false` (nepravda).

`a<>b`

  Alternativní operátor nerovnosti, vrací `true` (pravda) v případě, že `a` se nerovná `b`, jinak vrací `false` (nepravda).

`a<=b`

  Operátor menší než nebo rovno, vrací `true` (pravda) v případě, že `a` je menší než nebo se rovná `b`, jinak vrací `false` (nepravda). Je možné řetězit ve stylu `a <= b <= c` (a může se při tom kombinovat s operátorem menší než).

`a>=b`

  Operátor větší než nebo rovno, vrací `true` (pravda) v případě, že `a` je větší než nebo se rovná `b`, jinak vrací `false` (nepravda). Je možné řetězit ve stylu `a >= b >= c` (a může se při tom kombinovat s operátorem větší než).

`a<b`

  Operátor menší než, vrací `true` (pravda) v případě, že `a` je menší než `b`, jinak vrací `false` (nepravda). Je možné řetězit ve stylu `a < b < c` (a může se při tom kombinovat s operátorem menší než nebo rovno).

`a>b`

  Operátor větší než, vrací `true` (pravda) v případě, že `a` je větší než `b`, jinak vrací `false` (nepravda). Je možné řetězit ve stylu `a > b > c` (a může se při tom kombinovat s operátorem větší než nebo rovno).

`a<=>b`

  Operátor porovnání. V případě, že `a` je rovno `b`, vrací 0, pokud je `a` menší než `b` vrací -1 a pokud je `a` větší než `b`, vrací 1.

`a and b`

  Logické A (AND). Vrací pravda, když `a` i `b` jsou pravda, ve všech ostatních případech nepravda. Pokud jsou předána čísla, je se všemi nenulovými zacházeno jako s pravdivostní hodnotou pravda.

`a or b`

  Logické NEBO (OR). Vrací pravda, když je `a` nebo `b` (nebo oboje) pravda, jinak vrací nepravda. Pokud jsou předána čísla, je se všemi nenulovými zacházeno jako s pravdivostní hodnotou pravda.

`a xor b`

  Logické vylučovací NEBO (XOR). Vrací pravda, když právě `a` nebo `b` je pravda, ve všech ostatních případech vrací nepravda. Pokud jsou předána čísla, je se všemi nenulovými zacházeno jako s pravdivostní hodnotou pravda.

`not a`

  Logická negace (NOT). Vrací logickou negaci `a`.

`-a`

  Operátor negace. Vrací opačné číslo nebo matici (u matice pracuje prvek po prvku).

`&a`

  Reference proměnné (pro předání odkazu na proměnnou). Viz .

`*a`

  Dereference proměnné (pro přístup k odkazované proměnné). Viz .

`a'`

  Transponovat matici komplexně sdruženou (Hermiteovsky sdružená matice). Tj. řádky a sloupce se prohodí a vezmou se komplexně sdružená čísla ke všem prvkům. To znamená, že když prvek i,j matice `a` je x+iy, pak prvek j,i matice `a'` je x-iy.

`a.'`

  Transponovat matici (bez komplexního sdružení). To znamená, že prvek i,j matice `a` se stane prvkem j,i matice `a.'`.

`a@(b,c)`

  Získat prvek matice v řádku `b` a sloupci `c`. Pokud jsou `b`, `c` vektory, získají se odpovídající řádky, sloupce nebo podmatice.

`a@(b,)`

  Získat řádek matice (nebo více řádků, pokud je `b` vektor).

`a@(b,:)`

  Stejné jako předchozí.

`a@(,c)`

  Získat sloupec matice (nebo sloupce, pokud je `c` vektor).

`a@(:,c)`

  Stejné jako předchozí.

`a@(b)`

  Získat prvek z matice, s kterou se zachází jako s vektorem. Matice se prochází řádek pro řádku.

`a:b`

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

      A@(2:4,)

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

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

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

  Když jsou použita desetinná čísla, například `1.0:0.4:3.0`, je výstupem to, co očekáváte, přestože se k 1,0 pětkrát přidá 0,4, je to jen o něco více než 3,0 z důvodu, jakým jsou desetinná čísla uchována ve dvojkové soustavě (není to přesně 0,4, ale uložené číslo je obvykle o trochu větší). Způsob, jakým je to zpracováváno, je stejný jako u cyklu a sčítacích a násobících smyček. Pokud je konec v rámci `2^-20`násobku velikosti kroku koncového bodu, je koncový bod použit a předpokládá se, že nastaly chyby zaokrouhlení. To sice není perfektní, ale řeší to většinu případů. Tato kontrola se provádí až ve verzi 1.0.18 a novějších, takže provádění vašeho kódu může být ve starších verzích odlišné. Pokud chcete této záležitosti předejít, používejte opravdová racionální čísla, případně použijte funkci `float`, když si přejete na konci dostat desetinné číslo. Například `1:2/5:3` funguje správně a `float(1:2/5:3)` vám poskytne desetinné číslo a přitom to bude nepatrně přesnější než `1.0:0.4:3.0`.

`(a)i`

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

      (a)*1i

``a`

  Uvozovat identifikátor, kterýžto nebude vyhodnocen. Nebo uvozovat matici, takže nebude rozšířena.

`a swapwith b`

  Přehodit hodnotu proměnné `a` s hodnotou proměnné `b`. V současnosti nepracuje s částmi prvků matice. Vrací `null`. Dostupné od verze 1.0.13.

`increment a`

  Zvýšit hodnotu proměnné `a` o 1. V případě, že `a` je matice, je o 1 zvýšen každý prvek. Dělá to vlastně to stejné co `a=a+1`, akorát o něco rychleji. Vrací `null`. Dostupné od verze 1.0.13.

`increment a by b`

  Zvýšit hodnotu proměnné `a` o `b`. V případě, že `a` je matice, je o zvýšen každý prvek. Dělá to vlastně to stejné co `a=a+b`, akorát o něco rychleji. Vrací `null`. Dostupné od verze 1.0.13.

Operátor @() dává operátoru : více možností. S ním můžete určovat části matice. Takže a@(2:4,6) jsou řádky 2,3,4 sloupce 6. Nebo a@(,1:2) vám dá první dva sloupce matice. Do operátoru @() můžete i přiřazovat, stačí když je pravou hodnotou matice o stejném rozměru jako určená oblast nebo je to jiný typ hodnoty.

Porovnávací operátory (vyjma operátoru <=>, který se chová normálně) nejsou striktně binární operátory, mohou být fakticky seskupovány běžným matematickým způsobem, např.: (1<x<=y<5) je platný pravdivostní výraz a znamená přesně to, co by měl, tj. (1<x a x≤y a y<5)

Note that the unary minus operator binds less closely than the exponential, so `-1^k` is really `-(1)^k`. If you want `(-1)^k` you need the parentheses. Older versions of genius used to parse `-1^k` specially, but this was not reasonable and was removed in 1.0.28. So if in doubt, add parentheses.

## Programování s jazykem GEL

### Podmínky

Syntax:

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

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

Examples:

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

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

    if a=5 then a=a-1

will be interpreted as:

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

### Smyčky

#### Smyčky while

Syntax:

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

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

#### Smyčky for

Syntax:

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

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

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

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

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

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

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

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

#### Smyčky foreach

Syntax:

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

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

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

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

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

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

#### Break a continue

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

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

### Součty a součiny

Syntax:

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

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

Pokud tělo není vůbec provedeno (například `sum i=1 to 0 do …`), vrátí `sum` hodnotu 0 a `prod` hodnotu 1, což je standardní konvence.

Pro desetinná čísla se dělá stejná ochrana proti chybám zaokrouhlování jako u smyčky for. Viz .

### Porovnávací operátory

V jazyce GEL jsou podporovány následující porovnávací operátory a mají obvyklý význam: `==`, `>=`, `<=`, `!=`, `<>`, `<`, `>`. Vrací `true` nebo `false`. Operátory `!=` a `<>` jsou stejné a znamenají „není rovno“. GEL podporuje také operátor `<=>`, který vrací -1, když je levá strana menší, 0, když jsou si strany rovny, a 1, když je levá strana větší.

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

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

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

Všechny operátory porovnávání (vyjma operátoru `<=>`, který se chová normálně) nejsou striktně binární operátory, takže mohou být seskupovány běžným matematickým způsobem, např. (`1<x<=y<5`) je platný pravdivostní výraz a znamená přesně to, co by měl, což je (1<x a x≤y a y<5)

Pro sestavení logických výrazů používejte slov `not`, `and`, `or` a `xor`. Operátory `or` a `and` jsou zrádné v tom, že vyhodnocují své argumenty jeden po druhém, takže zde funguje obvyklý trik pro podmíněné vyhodnocení. Například `1 or a=1` nikdy nenastaví `a=1`, protože první argument je pravdivý.

### Globální proměnné a působnost proměnných

GEL je jazyk s dynamickým rozsahem platnosti. Co to znamená hned vysvětlíme. Je to to, že normální proměnné a funkce mají dynamicky vymezenou platnost. Výjimkou jsou proměnné parametrů, kterou jsou vždy globální.

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

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

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

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

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

Argumenty funkce jsou úplně stejné jako proměnné definované uvnitř funkce vyjma toho, že jsou inicializovány na hodnotu, která je funkci předána. Kromě této jediné věci se s nimi zachází úplně stejně, jako se všemi ostatními proměnnými definovanými uvnitř funkce.

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

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

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

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

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

    set(`a,3)

or:

    set("a",3)

Funkce `set` nastavuje vždy globální proměnné v nejvyšší úrovni. Neexistuje žádný způsob, jak nastavit lokální proměnnou v nějaké funkce z podřízené funkce. Pokud něco takového potřebujete, musíte jedině použít předání reference (odkazu).

Viz také funkce `SetElement` a `SetVElement`.

Takže sesumírováno do technického jazyka: Genius pracuje s různými očíslovanými kontexty. Nejvyšší úroveň je kontext 0 (nula). Kdykoliv se vstoupí do funkce, je kontext zvýšen a když se funkce opouští, je kontext snížen. Funkce nebo proměnná je vždy viditelná ze všech kontextů, které mají vyšší číslo. Když byla proměnná definována v kontextu s nižším číslem, má nastavení této proměnné vliv na vytváření nové lokální proměnné v aktuálním čísle kontextu a tato proměnná bude nyní viditelná ze všech kontextů s vyšším číslem.

Existují i skutečně lokální proměnné, které nejsou vidět nikde jinde, než v aktuálním kontextu. Rovněž při vracení funkcí hodnotou je možné odkazovat na proměnnou, která není viditelná z vyššího kontextu a to může být problém. Viz oddíl Skutečně lokální proměnné a Vracení funkcí.

### Proměnné parametrů

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

    parameter foo = 1

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

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

Některé parametry jsou vestavěné a mění chování kalkulátoru Genius.

### Návrat hodnot

Normálně je funkce tvořena jedním nebo několika výrazy oddělenými středníky a vrací se hodnota posledního výrazu. To je fajn pro jednoduché funkce, ale někdy nechcete, aby funkce vracela to, co vypočítala naposledy. Můžete se například chtít vrátit z prostředku funkce. V takovém případě můžete použít klíčové slovo `return`. `return` přebírá jeden argument, který je hodnotou, která bude vrácena.

Example:

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

### Reference

Pro některé funkce je nutné, aby vracely více než jednu hodnotu. To lze zajistit vrácením vektoru hodnot, ale častokrát je praktičtější použít předávání reference (odkazu) na proměnnou. Předáte funkci referenci na proměnnou a funkce proměnnou nastaví pomocí dereference. Nemusíte se s používáním referencí omezovat jen na tento účel, ale tohle je jejich hlavní využití.

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

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

V detailech fungování a syntaxi jsou reference podobné jako v jazyku C. Operátor `&` odkazuje na proměnnou a `*` provádí dereferenci proměnné. Obojí lze uplatnit pouze na identifikátory, takže `**a` není v jazyce GEL platný výraz.

References are best explained by an example:

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

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

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

gives us 4.

The first time a variable is referenced, it is created in the current context unless it exists. So if we make a function that sets the variable to 2, such as `function f(k) = (*k=2)`, then the call `f(&n)` will declare a new variable `n` then the function `f` will run and set it to 2. So there is no need to write something like `n=0;f(&n)`. A new variable in the current context is created even if a variable exists in a higher context, such as in the global context. So for example after

    n=3;
    function f(k) = (*k=2);
    function g() = (f(&n);print(n));
    g();

the variable `n` is still 3 and not 2. That is because inside `g`, when `n` is referenced, it is a new variable in the context of `g`. The function `f` then sets this `n` to 2, and then 2 is printed, but the `n` in the global context is not touched. So we can use references to get values out of functions and we do not need to explicitly declare them, nor do we have to worry about messing up global variables that the user might be using for something else.

### L-hodnoty

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

`a`

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

`*a`

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

`a@(<region>)`

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

Examples:

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

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

## Pokročilé programování v jazyce GEL

### Obsluha chyb

Pokud je zjištěna chyba ve vaší funkci, provádění funkce se přeruší. Pro normální chyby, jako jsou nesprávné typy argumentů, můžete vyvolat selhání funkce přidáním výrazu `bailout`. Když nastane něco opravdu špatného a vy chcete aktuální výpočet kompletně zabít, můžete použít `exception`.

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

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

### Syntaxe v nejvyšší úrovni

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

For example,

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

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

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

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

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

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

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

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

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

### Vracení funkcí

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

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

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

    g = f();
    g(5)

And `g(5)` should return 10.

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

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

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

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

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

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

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

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

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

### Skutečně lokální proměnné

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

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

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

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

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

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

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

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

Je dobrým zvykem, aby všechny funkce, které přebírají jiné funkce jako argumenty, používaly lokální proměnné. Je to způsob, jak zabránit, aby předávaná funkce neviděla implementační podrobnosti a nemátlo ji to.

### Spouštěcí procedura GEL

Nejdříve program hledá soubor nainstalovaných knihoven (přeložená verze `lib.cgel`) v instalační složce, pak se dívá do aktuální složky a po té zkouší načíst nepřeložený soubor nazvaný `~/.geniusinit`.

Pokaždé, když změníte knihovnu v místě její instalace, musíte ji nejprve přeložit pomocí `genius --compile loader.gel > lib.cgel`

### Načítání programů

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

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

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

    cd directory_with_gel_programs
    ls *.gel

## Matice v jazyce GEL

Genius podporuje vektory a matice a jeho součástí je rozsáhlá knihovna pro práci s maticemi a s funkcemi lineární algebry.

### Zadávání matic

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

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

or

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

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

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

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

and you should get

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

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

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

    [1, 2, 3
     4, 5
     6]

will end up being

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

Když jsou matice vyhodnocovány, jsou vyhodnocovány a procházeny po řádcích. Je to úplně stejné jako operátor `M@(j)`, který prochází matice po řádcích.

Věnujte pozornost při vracení z výrazů uvnitř závorek `[ ]`, protože tam mají lehce odlišný význam. Začnete tím nový řádek.

### Operátor konjugované transpozice a transpozice

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

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

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

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

Poznamenejme, že normální transpozice, tj. operátor `.'`, je mnohem rychlejší a nevytváří novou kopii matice v paměti. Konjugovaná transpozice bohužel novou kopii vytváří. Při práci se skutečnými maticemi a vektory je doporučováno vždy používat operátor `.'`.

### Lineární algebra

Genius implementuje velmi užitečné rutiny pro lineární algebru a práci s maticemi. Viz Lineární algebra a Práce s maticemi v kapitole se seznamem funkcí GEL.

Rutiny lineární algebry implementované v jazyce GEL v současnosti nepochází s příliš testovaného balíku pro numeriku a proto by neměly být používány pro kritické numerické výpočty. Na druhou stranu Genius implementuje opravdu hodně operací lineární algebry s racionálními a celočíselnými koeficienty. Ty jsou přirozeně přesné a v praxi vám poskytnou mnohem lepší výsledky, než běžné rutiny pro lineární algebru s dvojitou přesností.

Například je pro praktické účely zbytečné počítat hodnost nebo nulový prostor matice desetinných čísel, musíme vzít v úvahu, že matice mají určité malé chyby. To může vést k tomu, že získáte jiné výsledky, než očekáváte. Problém je, že za malou odchylkou každé matice je plná hodnost a invertovatelnost. Avšak pokud je matice z racionálních čísel, pak hodnost a nulový prostor jsou vždy přesné.

Vzato obecně, když Genius počítá podle určitého prostoru vektorů (například s funkcí `NullSpace`), získá báze jako matici, ve které jsou sloupce vektory báze. Když Genius mluví o lineárním podprostoru, míní tím matici, jejíž prostor sloupců je daný lineární podprostor.

Měli byste vzít na vědomí, že Genius si umí zapamatovat určité vlastnosti matice. Například si bude pamatovat, že je v řádkově redukované podobě. Když je prováděno hodně volání funkcí, které interně používají řádkově redukovanou matici, můžeme matici řádkově redukovat dopředu. Postupná volání `rref` budou velmi rychlá.

## Polynomy v jazyce GEL

V současnosti Genius umí pracovat s polynomy jedné proměnné zapsanými jako vektory a umí s nimi některé základní operace. Do budoucna se počítá s rozšířením této funkcionality.

### Používání polynomů

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

    [1,2,3]

translates to a polynomial of

    1 + 2*x + 3*x^2

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

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

gives

    3*y^2 + 2*y + 1

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

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

Rovněž je možné hledat kořeny polynomů 1. až 4. stupně pomocí funkce `PolynomialRoots`, která volá funkce s příslušnými vzorci. Vyšší stupně polynomů musí být převedeny na funkce a řešeny numericky pomocí funkcí, jako je `FindRootBisection`, `FindRootFalsePosition`, `FindRootMullersMethod` nebo `FindRootSecant`.

Ohledně ostatních funkcí týkajících se polynomů se podívejte se na v seznamu funkcí.

## Teorie množin v jazyce GEL

Genius má vestavěnou základní funkcionalitu pro teorii množin. V současnosti je množina prostě jen vektor (nebo matice). S každým jednotlivým objektem je zacházeno jako s odlišným prvkem.

### Používání množin

Podobně jako u vektorů, i v množinách mohou být objekty čísla, řetězce, `null`, matice a vektory. Do budoucna je pro množiny plánován samostatný typ namísto vektorů. Upozorňujeme, že desetinná čísla (float) se odlišují od celých čísel (integer), i když vypadají stejně. Takže Genius bude s `0` a `0.0` zacházet jako s různými prvky. `null` je považováno za prázdnou množinu.

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

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

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

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

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

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

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

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

## Seznam funkcí GEL

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

    help FunctionName

### Příkazy

help

      help

      help NázevFunkce

  Vypsat nápovědu (nebo nápovědu k funkci/příkazu).

load

      load "soubor.gel"

  Načíst soubor do interpretru. Obsah souboru bude proveden stejně, jako by byl napsán do příkazového řádku.

cd

      cd /název/složky

  Změnit pracovní složku na `/název/složky`.

pwd

      pwd

  Vypsat název aktuální pracovní složky.

ls

      ls

  Vypsat soubory v aktuální složce.

plugin

      plugin název_zásuvného_modulu

  Načíst zásuvný modul. Zásuvný modul se zadaným názvem musí být v systému nainstalován ve správné složce.

### Základy

AskButtons

      AskButtons (otazka)

      AskButtons (otazka, tlacitko1, ...)

  Položit uživateli otázku a poskytnout mu seznam tlačítek (nebo nabídku voleb v textovém režimu). Vrací index zmáčknutého tlačítka. Index začíná od jedné, tj. vrací 1, když je zmáčknuto první tlačítko, 2, když je zmáčknuto druhé tlačítko atd. Pokud uživatel zavře okno (nebo prostě zmáčkne Enter v textovém režimu), je vráceno `null`. Dokud uživatel nezareaguje, je další provádění programu blokováno.

  Verze 1.0.10 a novější.

AskString

      AskString (otazka)

      AskString (otazka, vychozi)

  Položit uživateli otázku a umožnit mu zadat řetězec, který pak bude vrácen. Pokud uživatel dotaz zruší nebo okno zavře, bude vráceno `null`. Provádění programu je blokováno, dokud uživatel neodpoví. Pokud je zadán argument `vychozi`, bude uživateli předvyplněn, takže mu bude stačit zmáčknout Enter (od verze 1.0.6).

Compose

      Compose (f,g)

  Složit dvě funkce a vrátit funkci, která je spojením `f` a `g`.

ComposePower

      ComposePower (f,n,x)

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

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

Evaluate

      Evaluate (retezec)

  Analyzovat a vyhodnotit řetězec.

GetCurrentModulo

      GetCurrentModulo

  Získat aktuální modulo z kontextu mimo funkci. To jest, pokud jste mimo funkci spuštěnou v modulární aritmetice (pomocí `mod`), bude vráceno to, co bylo tímto zbytkem. Normálně není tělo volané funkce prováděno v modulární aritmetice a díky této vestavěné funkci je možné, aby funkce GEL probíhaly v modulární aritmetice.

Identity

      Identity (x)

  Funkce identity, která vrací svůj argument. Odpovídá to `function Identity(x)=x`.

IntegerFromBoolean

      IntegerFromBoolean (pravdhodnota)

  Udělat z pravdivostní hodnoty celé číslo (0 pro `false` nebo 1 pro `true`). `pravdhodnota` může být i číslo, v kterém tož případě bude nenulová hodnota brána jako `true` a nulová jako `false`.

IsBoolean

      IsBoolean (argument)

  Zkontrolovat, zda je argument pravdivostní hodnota (a ne číslo).

IsDefined

      IsDefined (id)

  Zkontrolovat, zda je id definováno. Měli byste předat řetězec nebo identifikátor. Pokud předáte matici, bude každá položka vyhodnocena samostatně a matice by měla obsahovat řetězce nebo identifikátory.

IsFunction

      IsFunction (argument)

  Zkontrolovat, zda je argument funkcí.

IsFunctionOrIdentifier

      IsFunctionOrIdentifier (argument)

  Zkontrolovat, zda je argument funkcí nebo identifikátorem.

IsFunctionRef

      IsFunctionRef (argument)

  Zkontrolovat, zda je argument odkazem na funkci. Zahrnuje to i odkazy na proměnné.

IsMatrix

      IsMatrix (argument)

  Zkontrolovat, zda je argument maticí. Ačkoliv je `null` občas považováno za prázdnou matici, funkce `IsMatrix` hodnotu `null` za matici nepovažuje.

IsNull

      IsNull (argument)

  Zkontrolovat, zda je argument `null`.

IsString

      IsString (argument)

  Zkontrolovat, zda je argument textovým řetězcem.

IsValue

      IsValue (argument)

  Zkontrolovat, zda je argument číslem.

Parse

      Parse (retezec)

  Analyzovat, ale nevyhodnocovat řetězec. Berte ale na vědomí, že během fáze analýzy se provádí určité předvýpočty.

SetFunctionFlags

      SetFunctionFlags (id,priznaky...)

  Nastavit příznaky pro funkci, v současnosti jsou k dispozici `"PropagateMod"` a `"NoModuloArguments"`. Pokud je nastaveno `"PropagateMod"`, je vyhodnocování těla funkce prováděno v modulární aritmetice v situaci, kdy je funkce volána uvnitř bloku, který je vyhodnocován v modulární aritmetice (pomocí `mod`). Pokud je nastaveno `"NoModuloArguments"`, nejsou argumenty funkce nikdy vyhodnocovány pomocí modulární aritmetiky.

SetHelp

      SetHelp (id,kategorie,popis)

  Nastavit kategorii funkce a řádek jejího popisu v nápovědě.

SetHelpAlias

      SetHelpAlias (id,altnazev)

  Nastavit alternativní název do nápovědy.

chdir

      chdir (složka)

  Změnit aktuální složku, stejné jako `cd`.

CurrentTime

      CurrentTime

  Vrátit aktuální UNIXový čas s přesností na mikrovteřiny v podobě desetinného čísla. Prakticky se jedná o počet vteřin uplynulých od 1. ledna 1970.

  Verze 1.0.15 a novější.

display

      display (retezec,vyraz)

  Zobrazit retezec a vyraz navzájem oddělené dvojtečkou.

DisplayVariables

      DisplayVariables (prom1,prom2,...)

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

      DisplayVariables(`x,`y,`z)

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

      DisplayVariables()

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

  Verze 1.0.18 a novější.

error

      error (retezec)

  Vypsat retezec do chybového proudu (na konzole).

exit

      exit

  Alternativní názvy: `quit`

  Ukončit program.

false

      false

  Aliases: `False` `FALSE`

  Pravdivostní hodnota `false` (nepravda).

manual

      manual

  Zobrazit uživatelskou příručku.

print

      print (retezec)

  Vypsat výraz a poté odřádkovat. Argument `retezec` může být libovolný výraz. Před vypsáním je převeden na řetězec.

printn

      printn (retezec)

  Vypsat výraz bez odřádkování. Argument `retezec` může být libovolný výraz. Před vypsáním je převeden na řetězec.

PrintTable

      PrintTable (f,v)

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

      PrintTable (f,[0:10])

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

  Verze 1.0.18 a novější.

protect

      protect (id)

  Ochránit proměnnou proti změnám. Stejný postup je použit u interních funkcí GEL, aby se zabránilo nechtěnému přepsání.

ProtectAll

      ProtectAll ()

  Ochránit všechny aktuálně definované proměnné, parametry a funkce proti změnám. Stejný postup je použit u interních funkcí GEL, aby se zabránilo nechtěnému přepsání. Normálně matematický nástroj Genius považuje nechráněné proměnné za definované uživatelem.

  Verze 1.0.7 a novější.

set

      set (id,hodnota)

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

      set(`x,1)

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

  Funkce vrací `hodnotu`, což je užitečné pro řetězení.

SetElement

      SetElement (id,radek,sloupec,hodnota)

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

      SetElement(`x,2,3,1)

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

  Argumenty `row` a `col` mohou být i rozsahy a sémanticky je to stejné, jako běžné nastavení prvků pomocí znaménka rovnosti.

  Funkce vrací `hodnotu`, což je užitečné pro řetězení.

  Dostupné ve verzi 1.0.18 a novějších.

SetVElement

      SetElement (id,prvek,hodnota)

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

      SetElement(`x,2,1)

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

  Argument `prvek` může být i rozsah a sémanticky je to stejné, jako běžné nastavení prvků pomocí znaménka rovnosti.

  Funkce vrací `hodnotu`, což je užitečné pro řetězení.

  Dostupné ve verzi 1.0.18 a novějších.

string

      string (s)

  Vytvořit řetězec. Vytvoří řetězec podle libovolného argumentu.

true

      true

  Aliases: `True` `TRUE`

  Pravdivostní hodnota `true` (pravda).

undefine

      undefine (id)

  Alternativní názvy: `Undefine`

  Zrušit definici proměnné. Což zahrnuje lokální a globální, všechny hodnoty ve všech úrovních kontextu jsou vymazány. Tato funkce by opravdu neměla být používána na lokální proměnné. Je možné předat i vektor identifikátorů a v takovém případě bude zrušena definice několika proměnných.

UndefineAll

      UndefineAll ()

  Zrušit definice všech nechráněných globálních proměnných (včetně funkcí a parametrů). Normálně matematický nástroj Genius považuje chráněné proměnné za funkce a proměnné definované systémem. Upozorňujeme, že funkce `UndefineAll` odstraní pouze globální definice symbolů, lokální ne, takže může být bezpečně spouštěna i z těla jiných funkcí.

  Verze 1.0.7 a novější.

unprotect

      unprotect (id)

  Zrušit ochranu proměnné proti změnám.

UserVariables

      UserVariables ()

  Vrátit vektor všech uživatelem definovaných (nechráněných) globálních proměnných.

  Verze 1.0.7 a novější.

wait

      wait (vteřiny)

  Čekat zadaný počet vteřin. Počet `vteřiny` musí být nezáporný. Nula se akceptuje a v takovém případě se nic neprovede, vyjma možnosti, že jsou zpracovány události uživatelského rozhraní.

  Protože od verze 1.0.18 může být argument `vteřiny` neceločíselný, bude například `wait(0.1)` čekat jednu desetinu vteřiny.

version

      version

  Vrátit verzi kalkulátoru Genius jako svislý 3prvkový vektor s hlavním číslem jako prvním, následuje vedlejší číslo a nakonec úroveň záplat.

warranty

      warranty

  Poskytnout informace o licenci.

### Parametry

AdaptiveGaussKronrodAbsoluteTolerance

      AdaptiveGaussKronrodAbsoluteTolerance = 1e-12

  The absolute tolerance bound used in `AdaptiveGaussKronrod` function which is the default algorithm for `NumericalIntegral`. The algorithm runs until the error is less than the maximum of the absolute tolerance and the relative tolerance times the integral approximation.

  Version 1.0.28 onwards.

AdaptiveGaussKronrodMaxIterations

      AdaptiveGaussKronrodMaxIterations = 10000

  The maximal number of iterations used in the `AdaptiveGaussKronrod` function which is the default algorithm for `NumericalIntegral`. After this limit is reached, an error is printed and null is returned.

  Version 1.0.28 onwards.

AdaptiveGaussKronrodRelativeTolerance

      AdaptiveGaussKronrodRelativeTolerance = 1e-12

  The relative tolerance bound used in `AdaptiveGaussKronrod` function which is the default algorithm for `NumericalIntegral`. The algorithm runs until the error is less than the maximum of the absolute tolerance and the relative tolerance times the integral approximation.

  Version 1.0.28 onwards.

ChopTolerance

      ChopTolerance = číslo

  Tolerance funkce `Chop`.

ContinuousNumberOfTries

      ContinuousNumberOfTries = číslo

  Kolik iterací zkusit pro nalezení limity pro spojitost a limit.

ContinuousSFS

      ContinuousSFS = číslo

  Kolik postupných kroků, aby to bylo v rámci tolerance pro výpočet spojitosti.

ContinuousTolerance

      ContinuousTolerance = číslo

  Tolerance pro spojitost funkcí a výpočet limity.

DerivativeNumberOfTries

      DerivativeNumberOfTries = číslo

  Kolik iterací zkusit pro nalezení limity pro derivaci.

DerivativeSFS

      DerivativeSFS = číslo

  Kolik postupných kroků, aby to bylo v rámci tolerance pro výpočet derivace.

DerivativeTolerance

      DerivativeTolerance = číslo

  Tolerance pro výpočet derivací funkcí.

ErrorFunctionTolerance

      ErrorFunctionTolerance = číslo

  Tolerance chybové funkce `ErrorFunction`.

FloatPrecision

      FloatPrecision = číslo

  Přesnost desetinných čísel.

FullExpressions

      FullExpressions = pravdivostní hodnota

  Vypisovat úplné výrazy, i když mají více než jeden řádek.

GaussDistributionTolerance

      GaussDistributionTolerance = číslo

  Tolerance funkce `GaussDistribution`.

IntegerOutputBase

      IntegerOutputBase = číslo

  Číselná soustava vypisovaných celých čísel.

IsPrimeMillerRabinReps

      IsPrimeMillerRabinReps = číslo

  Počet Miller-Rabinových testů, které se mají spustit na číslo před prohlášením, že je to prvočíslo, ve funkci `IsPrime`.

LinePlotDrawLegends

      LinePlotDrawLegends = true

  Říká kalkulátoru genius, aby vykresloval legendy pro funkce čárových grafů, jako třeba `LinePlot`.

LinePlotDrawAxisLabels

      LinePlotDrawAxisLabels = true

  Říká kalkulátoru genius, aby vykresloval popisky os pro funkce čárových grafů, jako třeba `LinePlot`.

  Verze 1.0.16 a novější.

LinePlotVariableNames

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

  Říká kalkulátoru genius, které názvy proměnných jsou použity jako výchozí názvy pro funkce čárových grafů, jako třeba `LinePlot` a spol.

  Verze 1.0.10 a novější.

LinePlotWindow

      LinePlotWindow = [x1,x2,y1,y2]

  Nastavuje meze pro funkce čárových grafů, jako třeba `LinePlot`.

MaxDigits

      MaxDigits = číslo

  Maximální počet číslic, který se má zobrazovat.

MaxErrors

      MaxErrors = číslo

  Maximální počet chyb, které se mají zobrazovat.

MixedFractions

      MixedFractions = pravdivostní hodnota

  Pokud je nastaveno na true, budou vypisovány složené zlomky.

NumericalIntegralFunction

      NumericalIntegralFunction = funkce

  Funkce používaná pro numerické integrování v `NumericalIntegral`.

  The function should take three arguments, the function, and the left and right limits of integration.

  By default it is the `AdaptiveGaussKronrod` which implements an adaptive algorithm based on the Gauss-Kronrod G7 K15 rule. The function should take three arguments, the function, and the left and right limits of integration.

  Since version 1.0.28 onwards, the function does not take the 4th parameter with the number of steps.

NumericalIntegralSteps

      NumericalIntegralSteps = číslo

  Default number of steps to perform in midpoint, left-hand, right-hand, trapezoid, and composite Simpson's rule. If any of these rules are used as the `NumericalIntegralFunction`, then that is the number of steps used when `NumericalIntegral` is called. By default, the adaptive Gauss-Kronrod method is used and it does not use this parameter.

OutputChopExponent

      OutputChopExponent = číslo

  Když je jiné číslo ve vypisovaném objektu (matici nebo hodnotě) větší než 10-OutputChopWhenExponent a vypisované číslo je menší než 10-OutputChopExponent, pak se místo tohoto čísla zobrazí `0.0`.

  Výstup není nikdy osekán, pokud je `OutputChopExponent` nula. Vždy musí být nezáporné celé číslo.

  Jestliže chcete, aby byl výstup vždy osekáván podle `OutputChopExponent`, tak nastavte `OutputChopWhenExponent` na cokoliv většího nebo rovného `OutputChopExponent`.

OutputChopWhenExponent

      OutputChopWhenExponent = číslo

  Kdy osekávat výstup. Viz `OutputChopExponent`.

OutputStyle

      OutputStyle = řetězec

  Styl výstupu, může jít o jeden z `normal`, `latex`, `mathml` nebo `troff`.

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

      OutputStyle = "latex"

ResultsAsFloats

      ResultsAsFloats = pravdivostní hodnota

  Před vypsáním převést všechny výsledky na desetinná čísla.

ScientificNotation

      ScientificNotation = pravdivostní hodnota

  Používat vědeckou notaci.

SlopefieldTicks

      SlopefieldTicks = [svisle,vodorovne]

  Nastavuje počet svislých a vodorovných měřítkových značek v grafu směrového pole. (Viz `SlopefieldPlot`).

  Verze 1.0.10 a novější.

SumProductNumberOfTries

      SumProductNumberOfTries = číslo

  Kolik iterací se má zkusit pro `InfiniteSum` a `InfiniteProduct`.

SumProductSFS

      SumProductSFS = číslo

  Kolik postupných kroků, aby to bylo v rámci tolerance pro `InfiniteSum` a `InfiniteProduct`.

SumProductTolerance

      SumProductTolerance = číslo

  Tolerance pro funkce `InfiniteSum` a `InfiniteProduct`.

SurfacePlotDrawLegends

      SurfacePlotDrawLegends = true

  Říká kalkulátoru genius, aby vykresloval legendy pro funkce grafů ploch, jako třeba `SurfacePlot`.

  Verze 1.0.16 a novější.

SurfacePlotVariableNames

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

  Říká kalkulátoru genius, které názvy proměnných jsou použity jako výchozí názvy pro funkce plošných grafů, tj. `SurfacePlot`. Uvědomte si, že `z` neodkazuje na závislou (svislou) osu, ale na nezávislou komplexní proměnnou `z=x+iy`.

  Verze 1.0.10 a novější.

SurfacePlotWindow

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

  Nastavuje meze pro vykreslování ploch. (Viz `SurfacePlot`)

VectorfieldNormalized

      VectorfieldNormalized = true

  Zda by měl mít graf vektorového pole normalizovanou délku šipek. Pokud je nastaveno na true, bude vektorové pole ukazovat pouze směr a ne velikost. (Viz `VectorfieldPlot`).

VectorfieldTicks

      VectorfieldTicks = [svisle,vodorovne]

  Nastavuje počet svislých a vodorovných měřítkových značek v grafu vektorového pole. (Viz `VectorfieldPlot`).

  Verze 1.0.10 a novější.

### Konstanty

CatalanConstant

      CatalanConstant

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

  Více informací najdete v encyklopediích Mathworld (text je v angličtině) a Wikipedia (text je v angličtině).

EulerConstant

      EulerConstant

  Alternativní názvy: `gamma`

  Eulerova konstanta gama. Někdy nazývaná také Eulerova-Mascheroniho konstanta.

  Více informací najdete v encyklopediíc Planetmath (text je v angličtině), Mathworld (text je v angličtině) a Wikipedia.

GoldenRatio

      GoldenRatio

  Zlatý řez.

  Více informací najdete v encyklopediích Planetmath (text je v angličtině), Mathworld (text je v angličtině) a Wikipedia.

Gravity

      Gravity

  Tíhové zrychlení na úrovni moře v metrech za sekundu na druhou. Jedná se o standardní gravitační konstantu 9,80665. Gravitace v končinách vašeho lesa se může lišit, kvůli jiné nadmořské výšce a kvůli tomu, že Země není ideálně kulatá a jednolitá.

  Více informací najdete v encyklopedii Wikipedia(text je v angličtině).

e

      e

  Základ přirozeného logaritmu. `e^x` je exponenciální funkce `exp`. Hodnota konstanty je přibližně 2,71828182846… Toto číslo bývá někdy nazýváno Eulerovo, ačkoliv existuje několik čísel rovněž nazývaných Eulerovo. Například konstanta gamma: `EulerConstant`.

  Více informací najdete v encyklopediích Planetmath (text je v angličtině), Mathworld (text je v angličtině) a Wikipedia.

pi

      pi

  Číslo pí, což je poměr obvodu kružnice vůči jejímu průměru. Přibližně to je 3,14159265359…

  Více informací najdete v encyklopediích Planetmath (text je v angličtině), Mathworld (text je v angličtině) a Wikipedia.

### Práce s čísly

AbsoluteValue

      AbsoluteValue (x)

  Alternativní názvy: `abs`

  Absolutní hodnota čísla `x`, případně modul v případě komplexního čísla `x`. U komplexního čísla to je vlastně vzdálenost `x` od počátku. Je to to stejné, jako `|x|`.

  Více informací najdete v encyklopedii Wikipedia, Planetmath (absolutní hodnota; text je v angličtině), Planetmath (absolutní hodnota komplexního čísla; text je v angličtině), Mathworld (absolutní hodnota; text je v angličtině) a Mathworld (absolutní hodnota komplexního čísla; text je v angličtině).

Chop

      Chop (x)

  Nahrazovat velmi malá čísla nulou.

ComplexConjugate

      ComplexConjugate (z)

  Aliases: `conj` `Conj`

  Vypočítá komplexně sdružené číslo ke komplexnímu číslu `z`. Pokud je `z` vektor nebo matice, vypočítají se komplexně sdružená čísla pro všechny prvky.

  Více informací najdete v encyklopedii Wikipedia.

Denominator

      Denominator (x)

  Získat jmenovatel racionálního čísla.

  Více informací najdete v encyklopedii Wikipedia.

FractionalPart

      FractionalPart (x)

  Vrátit část čísla za desetinnou čárkou.

  Více informací najdete v encyklopedii Wikipedia (text je v angličtině).

Im

      Im (z)

  Alternativní názvy: `ImaginaryPart`

  Vrátit imaginární část komplexního čísla. Například `Re(3+4i)` vyplodí 4.

  Více informací najdete v encyklopedii Wikipedia.

IntegerQuotient

      IntegerQuotient (m,n)

  Dělit beze zbytku.

IsComplex

      IsComplex (num)

  Zkontrolovat, jestli je argument komplexní (ne reálné) číslo. Tím se míní opravdu číslo, které není reálné. Takže `IsComplex(3)` vrátí `false`, zatímco `IsComplex(3-1i)` vrátí `true`.

IsComplexRational

      IsComplexRational (num)

  Zkontrolovat, zda je argument komplexní racionální číslo. Tzn., že jak reální, tak imaginární část jsou zadány jako racionální čísla. Racionálním se samozřejmě myslí, že „není uloženo jako desetinné číslo s plovoucí čárkou“.

IsFloat

      IsFloat (num)

  Zkontrolovat, zda je argument reálné desetinné číslo (ne komplexní).

IsGaussInteger

      IsGaussInteger (num)

  Alternativní názvy: `IsComplexInteger`

  Zkontrolovat, jestli je argument celé komplexní číslo. Celé komplexní číslo je číslo ve tvaru `n+1i*m`, kde `n` a `m` jsou celá čísla.

IsInteger

      IsInteger (num)

  Zkontrolovat, zda je argument celé číslo (ne komplexní).

IsNonNegativeInteger

      IsNonNegativeInteger (num)

  Zkontrolovat, zda je argument nezáporné reálné celé číslo. Tj. buď kladné celé číslo nebo nula.

IsPositiveInteger

      IsPositiveInteger (num)

  Alternativní názvy: `IsNaturalNumber`

  Zkontrolovat, zda je argument kladné reálné celé číslo. Upozorňujeme, že se řídíme konvencí, že 0 není přirozené číslo.

IsRational

      IsRational (num)

  Zkontrolovat, zda je argument racionální (ne komplexní) číslo. Racionální samozřejmě prostě znamená „není uloženo jako desetinné číslo s plovoucí čárkou“.

IsReal

      IsReal (num)

  Zkontrolovat, zda je argument reálné číslo.

Numerator

      Numerator (x)

  Získat čitatel racionálního čísla.

  Více informací najdete v encyklopedii Wikipedia.

Re

      Re (z)

  Alternativní názvy: `RealPart`

  Vrátit reálnou část komplexního čísla. Například `Re(3+4i)` vyplodí 3.

  Více informací najdete v encyklopedii Wikipedia.

Sign

      Sign (x)

  Alternativní názvy: `sign`

  Vrátit znaménko čísla. Konkrétně vrací `-1` u záporných čísel, `0` pro nulu a `1` u kladných čísel. Pokud je `x` komplexní hodnota, pak `Sign` vrací směr nebo 0.

ceil

      ceil (x)

  Alternativní názvy: `Ceiling`

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

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

  Měli byste být obezřetní a uvědomit si, že desetinná čísla jsou uchovávána v binární podobě, takže nemusí mít naprosto přesně tu hodnotu, kterou očekáváte. Například `ceil(420/4.2)` vrací 101 a ne 100, jak byste asi očekávali. To je tím, že 4,2 je ve skutečnosti uloženo jako nepatrně méně než 4,2. Pokud chcete přesné výsledky, použijte racionální vyjádření `42/10`.

exp

      exp (x)

  Exponenciální funkce. Jedná se o funkci `e^x`, kde `e` je základ přirozeného logaritmu.

  Více informací najdete v encyklopediích Planetmath (text je v angličtině), Mathworld (text je v angličtině) a Wikipedia.

float

      float (x)

  Udělá z čísla desetinné číslo. Tzn., že vrací hodnotu čísla `x` v podobě čísla s plovoucí desetinnou čárkou.

floor

      floor (x)

  Alternativní názvy: `Floor`

  Vrátit nejvyšší celé číslo, které je menší nebo rovno `n`.

ln

      ln (x)

  Přirozený logaritmus, logaritmus o základu `e`.

  Více informací najdete v encyklopediích Planetmath (text je v angličtině), Mathworld (text je v angličtině) a Wikipedia.

log

      log (x)

      log (x,b)

  Logaritmus `x` o základu `b` (v režimu modulární aritmetiky nazýván `DiscreteLog`), pokud není základ uveden, použije se `e`.

log10

      log10 (x)

  Logaritmus čísla `x` o základu 10.

log2

      log2 (x)

  Alternativní názvy: `lg`

  Logaritmus čísla `x` o základu 2.

max

      max (a,argumenty...)

  Aliases: `Max` `Maximum`

  Vrací maximum z argumentů nebo matice.

min

      min (a,argumenty...)

  Aliases: `Min` `Minimum`

  Vrátit minimum z argumentů nebo matice.

rand

      rand (velikost...)

  Generovat náhodné desetinné číslo z intervalu `[0,1)`. Pokud je zadána velikost, pak se vygeneruje matice (zadána dvě čísla) nebo vektor (zadáno jedno číslo) této velikosti.

randint

      randint (max,velikost...)

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

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

round

      round (x)

  Alternativní názvy: `Round`

  Zaokrouhlit číslo.

sqrt

      sqrt (x)

  Alternativní názvy: `SquareRoot`

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

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

  Více informací najdete v encyklopediích Wikipedia a Planetmath (text je v angličtině).

trunc

      trunc (x)

  Aliases: `Truncate` `IntegerPart`

  Oříznout číslo na celé číslo (vrátí celou část).

### Trigonometrie

acos

      acos (x)

  Alternativní názvy: `arccos`

  Funkce arkus kosinus (inverzní kosinus).

acosh

      acosh (x)

  Alternativní názvy: `arccosh`

  Funkce arkus hyperbolický kosinus (inverzní cosh).

acot

      acot (x)

  Alternativní názvy: `arccot`

  Funkce arkus kotangens (inverzní kotangens).

acoth

      acoth (x)

  Alternativní názvy: `arccoth`

  Funkce arkus hyperbolický kotangens (inverzní coth).

acsc

      acsc (x)

  Alternativní názvy: `arccsc`

  Funkce inverzní kosekans.

acsch

      acsch (x)

  Alternativní názvy: `arccsch`

  Funkce inverzní hyperbolický kosekans.

asec

      asec (x)

  Alternativní názvy: `arcsec`

  Funkce inverzní sekans.

asech

      asech (x)

  Alternativní názvy: `arcsech`

  Funkce inverzní hyperbolický sekans.

asin

      asin (x)

  Alternativní názvy: `arcsin`

  Funkce arkus sinus (inverzní sinus).

asinh

      asinh (x)

  Alternativní názvy: `arcsinh`

  Funkce arkus hyperbolický sinus (inverzní sinh).

atan

      atan (x)

  Alternativní názvy: `arctan`

  Vypočítat funkce arkus tangens (inverzní tangens).

  Více informací najdete v encyklopediích Mathworld (text je v angličtině) a Wikipedia.

atanh

      atanh (x)

  Alternativní názvy: `arctanh`

  Funkce arkus hyperbolický tangens (inverzní tanh).

atan2

      atan2 (y, x)

  Alternativní názvy: `arctan2`

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

  Více informací najdete v encyklopediích Mathworld (text je v angličtině) a Wikipedia.

cos

      cos (x)

  Vypočítat funkci kosinus.

  Více informací najdete v encyklopediích Wikipedia a Planetmath (text je v angličtině).

cosh

      cosh (x)

  Vypočítat funkci hyperbolický kosinus.

  Více informací najdete v encyklopediích Wikipedia a Planetmath (text je v angličtině).

cot

      cot (x)

  Funkce kotangens.

  Více informací najdete v encyklopediích Wikipedia a Planetmath (text je v angličtině).

coth

      coth (x)

  Funkce hyperbolický kotangens.

  Více informací najdete v encyklopediích Wikipedia a Planetmath (text je v angličtině).

csc

      csc (x)

  Funkce kosekans.

  Více informací najdete v encyklopediích Wikipedia a Planetmath (text je v angličtině).

csch

      csch (x)

  Funkce hyperbolický kosekans.

  Více informací najdete v encyklopediích Wikipedia a Planetmath (text je v angličtině).

sec

      sec (x)

  Funkce sekans.

  Více informací najdete v encyklopediích Wikipedia a Planetmath (text je v angličtině).

sech

      sech (x)

  Funkce hyperbolický sekans.

  Více informací najdete v encyklopediích Wikipedia a Planetmath (text je v angličtině).

sin

      sin (x)

  Vypočítat funkci sinus.

  Více informací najdete v encyklopediích Wikipedia a Planetmath (text je v angličtině).

sinh

      sinh (x)

  Vypočítat funkci hyperbolický sinus.

  Více informací najdete v encyklopediích Wikipedia a Planetmath (text je v angličtině).

tan

      tan (x)

  Vypočítat funkci tangens.

  Více informací najdete v encyklopediích Wikipedia a Planetmath (text je v angličtině).

tanh

      tanh (x)

  Funkce hyperbolický tangens.

  Více informací najdete v encyklopediích Wikipedia a Planetmath (text je v angličtině).

### Teorie čísel

AreRelativelyPrime

      AreRelativelyPrime (a,b)

  Jsou reálná celá čísla `a` a `b` nesoudělná? Vrací `true` nebo `false`.

  Více informací najdete v encyklopediích Planetmath (text je v angličtině), Mathworld (text je v angličtině) a Wikipedia.

BernoulliNumber

      BernoulliNumber (n)

  Vrátit `n`-té Bernoulliho číslo.

  Více informací najdete v encyklopediích Wikipedia (text je v angličtině) a Mathworld (text je v angličtině).

ChineseRemainder

      ChineseRemainder (a,m)

  Alternativní názvy: `CRT`

  Najít pomocí čínské věty o zbytcích `x`, které řeší systém zadaný vektorem `a`, a zbytky prvků `m`.

  Více informací najdete v encyklopediích Planetmath (text je v angličtině), Mathworld (text je v angličtině) a Wikipedia.

CombineFactorizations

      CombineFactorizations (a,b)

  Jsou-li dány dva rozklady, vrátit rozklad (faktorizaci) součinu.

  Viz Factorize.

ConvertFromBase

      ConvertFromBase (v,b)

  Převést vektor hodnot udávajících mocniny `b` na číslo.

ConvertToBase

      ConvertToBase (n,b)

  Převést číslo na vektor mocnin prvků o základu `b`.

DiscreteLog

      DiscreteLog (n,b,q)

  Najít diskrétní logaritmus `n` o základu `b` v Fq, konečné grupě řádu `q`, kde `q` je prvočíslo, pomocí Silverova-Pohligova-Hellmanova algoritmu.

  Více informací najdete v encyklopediích Planetmath (text je v angličtině), Mathworld (text je v angličtině) a Wikipedia.

Divides

      Divides (m,n)

  Zkontrolovat dělitelnost (zda `m` dělí `n`).

EulerPhi

      EulerPhi (n)

  Spočítat Eulerovu funkci fí pro `n`, to je počet celých čísel mezi 1 a `n`, relativně prvočíselných vůči `n`.

  Více informací najdete v encyklopediích Planetmath (text je v angličtině), Mathworld (text je v angličtině) a Wikipedia.

ExactDivision

      ExactDivision (n,d)

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

Factorize

      Factorize (n)

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

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

  Více informací najdete v encyklopedii Wikipedia.

Factors

      Factors (n)

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

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

FermatFactorization

      FermatFactorization (n,pokusy)

  Zkusit Fermatův rozklad `n` na `(t-s)*(t+s)`. Pokud to je možné, vrací `t` a `s` jako vektor, jinak vrací `null`. Argument `pokusy` určuje počet pokusu, než se výpočet vzdá.

  Jedná se o docela dobrý rozklad za předpokladu, že je vaše číslo součinem dvou přibližně stejně velkých čísel.

  Více informací najdete v encyklopedii Wikipedia (text je v angličtině).

FindPrimitiveElementMod

      FindPrimitiveElementMod (q)

  Najít první primitivní prvek v Fq, konečné grupě řádu `q`. Je samozřejmé, že `q` musí být prvočíslo.

FindRandomPrimitiveElementMod

      FindRandomPrimitiveElementMod (q)

  Najít náhodný primitivní prvek v Fq, konečné grupě řádu `q`. Je samozřejmé, že `q` musí být prvočíslo.

IndexCalculus

      IndexCalculus (n,b,q,S)

  Spočítat diskrétní logaritmus `n` o základu `b` v Fq, konečné grupě řádu `q` (`q` prvočíslo) pomocí faktorizační báze `S`. `S` by měl být sloupec prvočísel, pokud možno s druhým sloupcem předpočítaným pomocí `IndexCalculusPrecalculation`.

IndexCalculusPrecalculation

      IndexCalculusPrecalculation (b,q,S)

  Provést přípravný krok výpočtu funkce `IndexCalculus` pro logaritmy o základu `b` v Fq, konečné grupě řádu `q` (`q` prvočíslo), pro faktorizační bázi `S` (kde `S` je sloupcový vektor prvočísel). Logaritmy budou předpočítány a vráceny v druhém sloupci.

IsEven

      IsEven (n)

  Otestovat, zda je celé číslo sudé.

IsMersennePrimeExponent

      IsMersennePrimeExponent (p)

  Zjistit, jestli je kladné celé číslo `p` Mersennovo prvočíslo. Tj. zda 2p-1 je prvočíslo. Provádí se to hledáním v tabulce známých hodnot, která je relativně krátká. Viz také MersennePrimeExponents a LucasLehmer.

  Více informací najdete v encyklopediích Planetmath (text je v angličtině), Mathworld (text je v angličtině), GIMPS (text je v angličtině) a Wikipedia.

IsNthPower

      IsNthPower (m,n)

  Zjistit, jestli je racionální číslo `m` perfektní `n`-tou mocninou . Viz také IsPerfectPower a IsPerfectSquare.

IsOdd

      IsOdd (n)

  Otestovat, zda je celé číslo liché.

IsPerfectPower

      IsPerfectPower (n)

  Zkontrolovat, zda je celé číslo perfekntí mocninou ab.

IsPerfectSquare

      IsPerfectSquare (n)

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

IsPrime

      IsPrime (n)

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

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

  Více informací najdete v encyklopediích Planetmath (text je v angličtině), Mathworld (text je v angličtině) a Wikipedia.

IsPrimitiveMod

      IsPrimitiveMod (g,q)

  Zkontrolovat, zda je `g` primitivní v Fq, konečné grupě řádu `q`, kde `q` je prvočíslo. Pokud `q` není prvočíslo, jsou výsledky nesmyslné.

IsPrimitiveModWithPrimeFactors

      IsPrimitiveModWithPrimeFactors (g,q,f)

  Zkontrolovat, zda je `g` primitivní v Fq, konečné grupě řádu `q`, kde `q` je prvočíslo a `f` je vektor prvočíselných činitelů `q`-1. Pokud `q` není prvočíslo, jsou výsledky nesmyslné.

IsPseudoprime

      IsPseudoprime (n,b)

  Zda je `n` pseudoprvočíslo o základu `b`, ale ne prvočíslo, tj. jestli `b^(n-1) == 1 mod n`. Volá se funkce `PseudoprimeTest`.

IsStrongPseudoprime

      IsStrongPseudoprime (n,b)

  Zjistit, zda je `n` silné pseudoprvočíslo o základu `b`, ale ne prvočíslo.

Jacobi

      Jacobi (a,b)

  Alternativní názvy: `JacobiSymbol`

  Spočítat Jacobiho symbol (a/b) (b by mělo být liché).

JacobiKronecker

      JacobiKronecker (a,b)

  Alternativní názvy: `JacobiKroneckerSymbol`

  Spočítat Jacobiho symbol (a/b) s Kroneckerovým rozšířením (a/2)=(2/a), když `a` je liché, nebo (a/2)=0, když `a` je sudé.

LeastAbsoluteResidue

      LeastAbsoluteResidue (a,n)

  Vrátit zbytek `a` mod `n` s nejmenší absolutní hodnotou (v intervalu -n/2 až n/2).

Legendre

      Legendre (a,p)

  Alternativní názvy: `LegendreSymbol`

  Spočítat Legendrův symbol (a/p).

  Více informací najdete v encyklopediích Planetmath (text je v angličtině), Mathworld (text je v angličtině) a Wikipedia.

LucasLehmer

      LucasLehmer (p)

  Zjistit pomocí Lucasova-Lehmerova testu, zda je 2p-1 Mersennovo prvočíslo. Viz také MersennePrimeExponents a IsMersennePrimeExponent.

  Více informací najdete v encyklopediích Wikipedia (text je v angličtině), Planetmath (text je v angličtině) a Mathworld (text je v agličtině).

LucasNumber

      LucasNumber (n)

  Vrátit `n`-té Lucasovo číslo.

  Více informací najdete v encyklopediích Wikipedia (text je v angličtině), Planetmath (text je v angličtině) a Mathworld (text je v angličtině).

MaximalPrimePowerFactors

      MaximalPrimePowerFactors (n)

  Vrátit všechny maximální mocniny prvočísel v rozkladu čísla.

MersennePrimeExponents

      MersennePrimeExponents

  Vektor se známými exponenty Mersennových prvočísel, což je seznam kladných celých čísel `p` takových, že 2p-1 je prvočíslo. Viz také IsMersennePrimeExponent a LucasLehmer.

  Více informací najdete v encyklopediích Planetmath (text je v angličtině), Mathworld (text je v angličtině), GIMPS (text je v angličtině) a Wikipedia.

MillerRabinTest

      MillerRabinTest (n,opak)

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

  Více informací najdete v encyklopediích Planetmath (text je v angličtině), Mathworld (text je v angličtině) a Wikipedia.

MillerRabinTestSure

      MillerRabinTestSure (n)

  Použít Millerův-Rabinův test prvočíselnosti na `n` s tolika bázemi, že za předpokladu zobecněné Riemannovy hypotézy je výsledek deterministický.

  Více informací najdete v encyklopediích Planetmath (text je v angličtině), Mathworld (text je v angličtině) a Wikipedia.

ModInvert

      ModInvert (n,m)

  Vrátit převrácenou hodnotu n mod m.

  Více informací najdete v encyklopedii Mathworld (text je v angličtině).

MoebiusMu

      MoebiusMu (n)

  Vrátit Möbiovu funkci μ vyhodnocenu na `n`. Což znamená, že vrátí 0 v případě, že `n` není součin různých prvočísel, a `(-1)^k` v případě, že je součin `k` různých prvočísel.

  Více informací najdete v encyklopediích Planetmath (text je v angličtině), Mathworld (text je v angličtině) a Wikipedia.

NextPrime

      NextPrime (n)

  Vrátit nejmenší prvočíslo větší než `n`. Záporná prvočísla jsou považována za prvočísla, takže předchozí prvočíslo můžete získat jako `-NextPrime(-n)`.

  Tato funkce používá funkci `mpz_nextprime` z knihovny GMP, která zase používá pravděpodobnostní Millerův-Rabinův test (viz také `MillerRabinTest`). Pravděpodobnost falešné kladné odpovědi není nastavitelná, ale je dostatečně malá pro praktické účely.

  Více informací najdete v encyklopediích Planetmath (text je v angličtině), Mathworld (text je v angličtině) a Wikipedia.

PadicValuation

      PadicValuation (n,p)

  Vrátit p-adické ohodnocení (počet koncových nul v základu `p`).

  Více informací najdete v encyklopediích Wikipedia (text je v angličtině) a Planetmath (text je v angličtině).

PowerMod

      PowerMod (a,b,m)

  Spočítat `a^b mod m`. `b`-tá mocnina čísla `a` modulo `m`. Tuto funkci není nutné používat, protože se automaticky použije v režimu modulární aritmetiky. Z tohoto důvodu je `a^b mod m` stejně rychlé.

Prime

      Prime (n)

  Alternativní názvy: `prime`

  Vrátit `n`-té prvočíslo (až do limitu).

  Více informací najdete v encyklopediích Planetmath (text je v angličtině), Mathworld (text je v angličtině) a Wikipedia.

PrimeFactors

      PrimeFactors (n)

  Vrátit v podobě vektoru všechny prvočinitele čísla.

  Více informací najdete v encyklopediích Mathworld (text je v angličtině) a Wikipedia (text je v angličtině).

PseudoprimeTest

      PseudoprimeTest (n,b)

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

  Více informací najdete v encyklopediích Planetmath (text je v angličtině), Mathworld (text je v angličtině) a Wikipedia.

RemoveFactor

      RemoveFactor (n,m)

  Odstranit všechny instance činitele `m` z čísla `n`. Prakticky to znamená, že je poděleno nejvyšší mocninou čísla `m`, která je dělitelem `n`.

  Více informací najdete v encyklopediích Planetmath (text je v angličtině), Mathworld (text je v angličtině) a Wikipedia.

SilverPohligHellmanWithFactorization

      SilverPohligHellmanWithFactorization (n,b,q,f)

  Najít diskrétní logaritmus `n` o základu `b` v Fq, konečné grupě řádu `q`, kde `q` je prvočíslo, pomocí Silverova-Pohligova-Hellmanova algoritmu, dané `f` je rozkladem `q`-1.

SqrtModPrime

      SqrtModPrime (n,p)

  Najít druhou odmocninu z `n` modulo `p` (kde `p` je prvočíslo). Pokud není kvadratickým zbytkem, je vráceno null.

  Více informací najdete v encyklopedicíh Planetmath (text je v angličtině) a Mathworld (text je v angličtině).

StrongPseudoprimeTest

      StrongPseudoprimeTest (n,b)

  Spustit silný test pseudoprvočíselnosti o základu `b` na `n`.

  Více informací najdete v encyklopediích Planetmath (text je v angličtině), Mathworld (text je v angličtině) a Wikipedia (text je v angličtině).

gcd

      gcd (a,argumenty...)

  Alternativní názvy: `GCD`

  Největší společný dělitel celých čísel. V seznamu argumentů můžete uvést libovolný počet celých čísel, nebo je můžete zadat jako vektor nebo matici celých čísel. Pokud zadáte více než jednu matici stejné velikosti, bude největší společný dělitel určen prvek po prvku.

  Více informací najdete v encyklopediích Planetmath (text je v angličtině), Mathworld (text je v angličtině) a Wikipedia.

lcm

      lcm (a,argumenty...)

  Alternativní názvy: `LCM`

  Nejmenší společný násobek celých čísel. V seznamu argumentů můžete uvést libovolný počet celých čísel, nebo je můžete zadat jako vektor nebo matici celých čísel. Pokud zadáte více než jednu matici stejné velikosti, bude nejmenší společný násobek určen prvek po prvku.

  Více informací najdete v encyklopediích Planetmath (text je v angličtině), Mathworld (text je v angličtině) a Wikipedia.

### Práce s maticemi

AppendElement

      AppendElement (v,prvek)

  Přidá prvek do vektoru a vrátí vektor. Neprovádí se žádné rozšíření. Když začínáte z `null` nebo matice 1 krát 1, vytvoří se normálně řádkový vektor, ale když je předán sloupcový vektor, bude správně použit jako sloupcový vektor.

ApplyOverMatrix

      ApplyOverMatrix (a,fce)

  Použít funkci na všechny prvky matice a vrátit matici výsledků.

ApplyOverMatrix2

      ApplyOverMatrix2 (a,b,fce)

  Použít funkci na všechny prvky 2 matic (nebo 1 hodnoty a 1 matice) a vrátit matici výsledků.

ColumnsOf

      ColumnsOf (M)

  Vrátit sloupce matice jako vodorovný vektor.

ComplementSubmatrix

      ComplementSubmatrix (m,r,c)

  Odstranit sloupec (či slupce) a řádek (či řádky) z matice.

CompoundMatrix

      CompoundMatrix (k,A)

  Spočítat `k`-tou složenou matici matice A.

CountZeroColumns

      CountZeroColumns (M)

  Spočítat počet nulových sloupců v matici. Například, jakmile zredukujete sloupce matice, můžete to využít k nalezení nulovosti. Viz `cref` a `Nullity`.

DeleteColumn

      DeleteColumn (M,sloupec)

  Smazat sloupec matice.

DeleteRow

      DeleteRow (M,radek)

  Smazat řádek matice.

DiagonalOf

      DiagonalOf (M)

  Získat diagonální prvky matice jako sloupcový vektor.

  Více informací najdete v encyklopedii Wikipedia.

DotProduct

      DotProduct (u,v)

  Získat skalární součin dvou vektorů. Vektory musí mít stejnou velikost. Nepřijímají se konjugované vektory, protože jde o bilineární formu, i když pracuje i s komplexními čísly. Jedná se o bilineární skalární součin, ne půldruhý lineární (seskvilineární). Pro ten slouží funkce HermitianProduct

  Více informací najdete v encyklopediích Planetmath (text je v angličtině) a Wikipedia.

ExpandMatrix

      ExpandMatrix (M)

  Rozšířit matici, stejně když zadáte matici bez uvozovky. Takto se rozbalí do bloku libovolná interní matice. Je to způsob, jak sestrojit matice z jiných menších a normálně je to prováděno na vstupu automaticky, s výjimkou kdy je matice zadána s uvozovkou.

HermitianProduct

      HermitianProduct (u,v)

  Alternativní názvy: `InnerProduct`

  Získat hermitovský součin dvou vektorů. Vektory musí mít stejnou velikost. Jedná se o polybilineární formu používající jednotkovou matici.

  Více informací najdete v encyklopediích Mathworld (text je v angličtině) a Wikipedia (text je v angličtině).

I

      I (n)

  Alternativní názvy: `eye`

  Vrátit jednotkovou matici zadané velikosti, tj. `n` krát `n`. Pokud je `n` rovno 0, vrátí `null`.

  Více informací najdete v encyklopediích Planetmath (text je v angličtině) a Wikipedia.

IndexComplement

      IndexComplement (vektor,mvelikost)

  Vrátit doplňkový index vektoru indexů. Vše je s jednou bází. Například pro vektor `[2,3]` a velikost `5` dostaneme `[1,4,5]`. Pokud je `mvelikost` rovna 0, vrací vždy `null`.

IsDiagonal

      IsDiagonal (M)

  Je matice diagonální?

  Více informací najdete v encyklopediích Planetmath (text je v angličtině) nebo Wikipedia.

IsIdentity

      IsIdentity (x)

  Zkontrolovat, zda je matice jednotková. Pokud matice není čtvercová, tak automaticky vrátí `false`. Funguje i pro čísla, v kterémžto případě je to stejné jako `x==1`. Pokud je argument `x` roven `null` (což můžeme považovat za matici 0 krát 0), nezpůsobí to chybu a vrátí `false`.

IsLowerTriangular

      IsLowerTriangular (M)

  Jde o dolní trojúhelníkovou matici? To je taková, která má všechny prvky nad diagonálou nulové.

IsMatrixInteger

      IsMatrixInteger (M)

  Zkontrolovat, zda je matice maticí celých (nekomplexních) čísel.

IsMatrixNonnegative

      IsMatrixNonnegative (M)

  Zkontrolovat, zda je matice nezáporná, tj. zda je každý z prvků nezáporný. Nepleťte si pozitivní matice s pozitivně definitními maticemi.

  Více informací najdete v encyklopedii Wikipedia (text je v angličtině).

IsMatrixPositive

      IsMatrixPositive (M)

  Zkontrolovat, zda je matice pozitivní, tj. zda je každý z prvků kladný (a tudíž reálný). Především není žádný prvek 0. Nepleťte si positivní matice s pozitivně definitními maticemi.

  Více informací najdete v encyklopedii Wikipedia (text je v angličtině).

IsMatrixRational

      IsMatrixRational (M)

  Zkontrolovat, zda je matice maticí z racionálních (nekomplexních) čísel.

IsMatrixReal

      IsMatrixReal (M)

  Zkontrolovat, zda je matice složená z reálných (na komplexních) čísel.

IsMatrixSquare

      IsMatrixSquare (M)

  Zkontrolovat, zda je matice čtvercová, tj. šířka je stejná jako výška.

IsUpperTriangular

      IsUpperTriangular (M)

  Jde o horní trojúhelníkovou matici? To je taková, která má všechny prvky pod diagonálou nulové.

IsValueOnly

      IsValueOnly (M)

  Zkontrolovat, zda se matice skládá pouze z čísel. Mnoho interních funkcí provádí tuto kontrolu. Hodnoty mohou být libovolná čísla včetně komplexních.

IsVector

      IsVector (v)

  Je argument vodorovný nebo svislý vektor? Genius nerozlišuje mezi maticí a vektorem, vektor je prostě jen matice 1 krát `n` nebo `n` krát 1.

IsZero

      IsZero (x)

  Zkontrolovat, zda se matice skládá jen z nul. Funguje to i pro čísla, kdy je to ekvivalentní výrazu `x==0`. Když je `x` rovno `null` (můžeme to považovat za matici 0 krát 0), nezpůsobí to žádnou chybu, ale vrátí se `true`, protože podmínka je prázdná.

LowerTriangular

      LowerTriangular (M)

  Vrátit kopii matice `M` se všemi prvky nad diagonálou nastavenými na nulu.

MakeDiagonal

      MakeDiagonal (v,argument...)

  Alternativní názvy: `diag`

  Vytvořit diagonální matici z vektoru. Případně můžete hodnoty, které se mají umístit na diagonálu, zadat jako jednotlivé parametry. Takže `MakeDiagonal([1,2,3])` je to stejné jako `MakeDiagonal(1,2,3)`.

  Více informací najdete v encyklopediích Planetmath (text je v angličtině) nebo Wikipedia.

MakeVector

      MakeVector (A)

  Alternativní název: `MakeColumnVector`

  Vytvořit sloupcový vektor z matice poskládáním sloupců na sebe. Pokud je předáno `null`, vrátí `null`. Můžete si tím zajistit, že vektor bude opravdu sloupcový vektor.

MakeRowVector

      MakeRowVector (A)

  Vytvořit řádkový vektor z matice poskládáním řádků za sebe. Pokud je předáno `null`, vrátí `null`. Můžete si tím zajistit, že vektor bude skutečně řádkový vektor.

MatrixProduct

      MatrixProduct (A)

  Spočítat součin všech prvků matice nebo vektoru. To znamená, že se vynásobí všechny prvky a vrátí se číslo, které je násobkem všech těchto prvků.

MatrixSum

      MatrixSum (A)

  Spočítat součet všech prvků matice nebo vektoru. To znamená, že se sečtou všechny prvky a vrátí se číslo, které je součtem všech těchto prvků.

MatrixSumSquares

      MatrixSumSquares (A)

  Spočítat součet druhých mocnin všech prvků matice nebo vektoru.

NonzeroColumns

      NonzeroColumns (M)

  Vrátit řádkový vektor s indexy nenulových sloupců v matici `M`.

  Verze 1.0.18 a novější.

NonzeroElements

      NonzeroElements (v)

  Vrátit řádkový vektor s indexy nenulových prvků ve vektoru `v`.

  Verze 1.0.18 a novější.

OuterProduct

      OuterProduct (u,v)

  Získat vnější součin dvou vektorů. Takže, když dejme tomu jsou `u` a `v` svislé vektory, pak vnější součin je `v * u.'`.

ReverseVector

      ReverseVector (v)

  Převrátit pořadí prvků ve vektoru. Pokud je předáno `null`, tak vrací `null`.

RowSum

      RowSum (m)

  Vypočítat součet každého řádku v matici a vrátit svislý vektor s výsledkem.

RowSumSquares

      RowSumSquares (m)

  Vypočítat součet druhých mocnin každého řádku v matici a vrátit svislý vektor s výsledkem.

RowsOf

      RowsOf (M)

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

SetMatrixSize

      SetMatrixSize (M,radku,sloupcu)

  Vytvořit novou matici zadané velikosti z jiné staré. To znamená, že nová matice bude vrácena jako kopie té staré. Prvky, které přebývají, jsou odříznuty a volné místo je vyplněno nulami. Pokud je argument `radku` nebo `sloupcu` roven nule, je vráceno `null`.

ShuffleVector

      ShuffleVector (v)

  Zamíchat pořadí prvků ve vektoru. Pokud je předáno `null`, tak vrací `null`.

  Verze 1.0.13 a novější.

SortVector

      SortVector (v)

  Seřadit prvky vektoru ve vzestupném pořadí.

StripZeroColumns

      StripZeroColumns (M)

  Odstranit všechny čistě nulové sloupce matice `M`.

StripZeroRows

      StripZeroRows (M)

  Odstranit všechny čistě nulové řádky matice `M`.

Submatrix

      Submatrix (m,r,s)

  Vrátit sloupec (či sloupce) a řádek (či řádky) z matice. Je to stejné jako `m@(r,s)`. Argumenty `r` a `s` by měly být vektory se seznamy řádků a sloupců (nebo samostatná čísla, pokud požadujete jen jeden řádek nebo sloupec).

SwapRows

      SwapRows (m,radek1,radek2)

  Prohodit dva řádky v matici.

UpperTriangular

      UpperTriangular (M)

  Vrátit kopii matice `M` se všemi prvky pod diagonálou nastavenými na nulu.

columns

      columns (M)

  Vrátit počet sloupců matice.

elements

      elements (M)

  Vrátit celkový počet prvků matice. Tj. počet sloupců krát počet řádků.

ones

      ones (radku,sloupcu...)

  Vytvořit matici ze samých jedniček (nebo řádkový vektor, pokud je zadán jen jeden argument). Když je `radku` nebo `sloupcu` rovno nule, vrátí `null`.

rows

      rows (M)

  Vrátit počet řádků matice.

zeros

      zeros (radku,sloupcu...)

  Vytvořit matici celou z nul (nebo řádkový vektor, pokud je zadán jen jeden argument). Pokud je argument `radku` nebo `sloupcu` roven nule, je vráceno `null`.

### Lineární algebra

AuxiliaryUnitMatrix

      AuxiliaryUnitMatrix (n)

  Získat pomocnou jednotkovou matici velikosti `n`. Jde o čtvercovou matici ze samých nul vyjma diagonály, na které jsou jedničky. Je to Jordanův blok s jedním vlastním číslem nula.

  Více informací o Jordanově kanonické formě najdete v encyklopediích Planetmath (text je v angličtině), Mathworld (text je v angličtině) nebo Wikipedia.

BilinearForm

      BilinearForm (v,A,w)

  Spočítat (v,w) vzhledem k bilineární formě dané maticí A.

BilinearFormFunction

      BilinearFormFunction (A)

  Vrátit funkci takovou, že vyhodnocuje dva vektory vzhledem k bilineární formě dané maticí A.

CharacteristicPolynomial

      CharacteristicPolynomial (M)

  Alternativní názvy: `CharPoly`

  Získat charakteristický polynom v podobě vektoru. Konkrétně vrací koeficienty polynomu počínaje konstantním členem. Jedná se o polynom definovaný pomocí `det(M-xI)`. Kořeny tohoto polynomu jsou vlastní čísla matice `M`. Viz CharacteristicPolynomialFunction.

  Více informací najdete v encyklopediích Wikipedia (text je v anličtině) a Planetmath (text je v angličtině).

CharacteristicPolynomialFunction

      CharacteristicPolynomialFunction (M)

  Získat charakteristický polynom v podobě funkce. Jedná se o polynom definovaný pomocí `det(M-xI)`. Kořeny tohoto polynomu jsou vlastní čísla matice `M`. Viz CharacteristicPolynomial.

  Více informací najdete v encyklopediích Wikipedia (text je v anličtině) a Planetmath (text je v angličtině).

ColumnSpace

      ColumnSpace (M)

  Získat bázi matice pro prostor sloupců matice. Prakticky se vrátí matice, jejíž sloupce jsou bázemi pro prostor sloupců matice `M`. To je prostor rozložený podle sloupců matice `M`.

  Více informací najdete v encyklopedii Wikipedia (text je v angličtině).

CommutationMatrix

      CommutationMatrix (m, n)

  Vrátit komutační matici `K(m,n)`, což je jedinečná matice velikosti `m*n` krát `m*n`, která splňuje `K(m,n) * MakeVector(A) = MakeVector(A.')` pro všechny matice `A` velikosti `m` krát `n`.

CompanionMatrix

      CompanionMatrix (p)

  Doplňková matice polynomu (jako vektor).

ConjugateTranspose

      ConjugateTranspose (M)

  Konjugovaná transpozice matice (adjungovaná). Je to stejné jako operátor `'`.

  Více informací najdete v encyklopediích Wikipedia (text je v angličtině) a Planetmath (text je v angličtině).

Convolution

      Convolution (a,b)

  Alternativní názvy: `convol`

  Spočítat konvoluci dvou vodorovných vektorů.

ConvolutionVector

      ConvolutionVector (a,b)

  Spočítat konvoluci dvou vodorovných vektorů. Výsledek vrátí jako vektor a ne sečtené dohromady.

CrossProduct

      CrossProduct (v,w)

  Vektorový součin dvou vektorů v R3 jako sloupcový vektor.

  Více informací najdete v encyklopedii Wikipedia.

DeterminantalDivisorsInteger

      DeterminantalDivisorsInteger (M)

  Získat determinantové dělitele celočíselné matice.

DirectSum

      DirectSum (M,N...)

  Přímý součet matic.

  Více informací najdete v encyklopedii Wikipedia.

DirectSumMatrixVector

      DirectSumMatrixVector (v)

  Přímý součet vektoru matic.

  Více informací najdete v encyklopedii Wikipedia.

Eigenvalues

      Eigenvalues (M)

  Alternativní názvy: `eig`

  Získat vlastní čísla čtvercové matice. V současnosti pracuje pouze pro matice do velikosti 4 krát 4 nebo pro trojúhelníkové matice (pro které jsou vlastní čísla na diagonále).

  Více informací najdete v encyklopediích Planetmath (text je v angličtině), Mathworld (text je v angličtině) a Wikipedia.

Eigenvectors

      Eigenvectors (M)

      Eigenvectors (M,&vlastni_cisla)

      Eigenvectors (M, &vlastni_cisla, &nasobnosti)

  Získat vlastní vektory čtvercové matice. Volitelně získat také vlastní čísla a jejich algebraické násobnosti. V současnosti pracuje pouze s maticemi do velikosti 2 krát 2.

  Více informací najdete v encyklopediích Planetmath (text je v angličtině), Mathworld (text je v angličtině) a Wikipedia.

GramSchmidt

      GramSchmidt (v,B...)

  Použít Gramův-Schmidtův proces (na sloupce) vzhledem k unitárnímu prostoru danému `B`. Pokud `B` není zadáno, je použit standardní hermitovský součin. `B` může být buď polybilineární funkce dvou argumentů nebo to může být matice v polybilineární formě. Vektory budou vytvořeny ortogonální vzhledem k `B`.

  Více informací najdete v encyklopediích Planetmath (text je v angličtině) a Wikipedia.

HankelMatrix

      HankelMatrix (c,r)

  Henkelova matice, což je matice se stejnými vedlejšími diagonálami. `c` je první řádek a `r` je poslední sloupec. Předpokládá se, že oba argumenty budou vektory a poslední prvek `c` bude stejný jako první prvek `r`.

  Více informací najdete v encyklopedii Wikipedia (text je v angličtině).

HilbertMatrix

      HilbertMatrix (n)

  Hilbertova matice řádu `n`.

  Více informací najdete v encyklopediích Wikipedia (text je v angličtině) a Planetmath (text je v angličtině).

Image

      Image (T)

  Získat obraz (sloupcový prostor) lineární transformace.

  Více informací najdete v encyklopedii Wikipedia (text je v angličtině).

InfNorm

      InfNorm (v)

  Získat k vektoru normu typu nekonečno, někdy také nazývanou maximální norma.

InvariantFactorsInteger

      InvariantFactorsInteger (M)

  Získat invariantní činitele čtvercové celočíselné matice.

InverseHilbertMatrix

      InverseHilbertMatrix (n)

  Inverzní Hilbertova matice řádu `n`.

  Více informací najdete v encyklopediích Wikipedia (text je v angličtině) a Planetmath (text je v angličtině).

IsHermitian

      IsHermitian (M)

  Je matice hermitovská? Tj. zda je rovna své konjugované transpozici.

  Více informací najdete v encyklopediích Planetmath (text je v angličtině) a Wikipedia (text je v angličtině).

IsInSubspace

      IsInSubspace (v,W)

  Zjistit, zda je vektor v podprostoru.

IsInvertible

      IsInvertible (n)

  Je matice (nebo číslo) invertovatelná (matice celých čísel je invertovatelná, když je invertovatelná nad celými čísly)?

IsInvertibleField

      IsInvertibleField (n)

  Je matice (nebo číslo) invertovatelná nad tělesem.

IsNormal

      IsNormal (M)

  Je `M` normální matice. To jest, zda `M*M' == M'*M`.

  Více informací najdete v encyklopediích Planetmath (text je v angličtině) nebo Mathworld (text je v angličtině).

IsPositiveDefinite

      IsPositiveDefinite (M)

  Je matice `M` hermitovská pozitivně definitní matice? To znamená, zda je `HermitianProduct(M*v,v)` vždy striktně pozitivní pro libovolný vektor `v`. `M` musí být čtvercová a hermitovská, aby byla pozitivně definitní. Kontrola, zda tomu tak je, spočívá v tom, zda každá hlavní podmatice má nezáporný determinant. (Viz HermitianProduct)

  Poznamenejme, že někteří autoři (např. Mathworld) nevyžadují, aby matice `M` byla hermitovská a tak podmínka není skutečnu částí unitárního prostoru, ale neberte to za dogma. Pokud chcete takovou kontrolu provést, jednoduše zkontrolujte hermitovskou část matice `M` takto: `IsPositiveDefinite(M+M')`.

  Více informací najdete v encyklopediích Planetmath (text je v angličtině), Mathworld (text je v angličtině) a Wikipedia.

IsPositiveSemidefinite

      IsPositiveSemidefinite (M)

  Je matice `M` hermitovská pozitivně semidefinitní matice? To znamená, zda je `HermitianProduct(M*v,v)` vždy nezáporná pro libovolný vektor `v`. `M` musí být čtvercová a hermitovská, aby byla pozitivně semidefinitní. Kontrola, zda tomu tak je, spočívá v tom, zda každá hlavní podmatice má nezáporný determinant. (Viz HermitianProduct)

  Poznamenejme, že někteří autoři (např. Mathworld) nevyžadují, aby matice `M` byla hermitovská a tak podmínka není skutečnu částí unitárního prostoru, ale neberte to za dogma. Pokud chcete takovou kontrolu provést, jednoduše zkontrolujte hermitovskou část matice `M` takto: `IsPositiveSemidefinite(M+M')`.

  Více informací najdete v encyklopediích Planetmath (text je v angličtině) nebo Mathworld (text je v angličtině).

IsSkewHermitian

      IsSkewHermitian (M)

  Je matice antihermitovská? To znamená, zda je konjugovaná transpozice rovna negativní matici.

  Více informací najdete v encyklopedii Planetmath (text je v angličtině).

IsUnitary

      IsUnitary (M)

  Je matice unitární? To je, zda `M'*M` a `M*M'` dají stejnou jednotkovou matici.

  Více informací najdete v encyklopediích Planetmath (text je v angličtině), Mathworld (text je v angličtině) nebo Wikipedia.

JordanBlock

      JordanBlock (n,lambda)

  Alternativní názvy: `J`

  Získat Jordanův blok odpovídající vlastnímu číslu `lambda` s násobností `n`.

  Více informací najdete v encyklopediích Planetmath (text je v angličtině), Mathworld (text je v angličtině) a Wikipedia.

Kernel

      Kernel (T)

  Získat jádro (nulový prostor) lineární transformace.

  (Viz NullSpace)

KroneckerProduct

      KroneckerProduct (M, N)

  Alternativní názvy: `TensorProduct`

  Spočítat Kroneckerův součin (tenzorový součin ve standardní bázi) dvou matic.

  Více informací najdete v encyklopediích Wikipedia (text je v angličtině), Planetmath (text je v angličtině) a Mathworld (text je v angličtině).

  Verze 1.0.18 a novější.

LUDecomposition

      LUDecomposition (A, L, U)

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

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

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

  Jedná se o LU rozklad matice známý také jako Croutův a/nebo Choleského rozklad. (ISBN 0-201-11577-8 pp.99-103) Horní trojúhelníková matice zahrnuje diagonálu hodnot 1. Nejedná se o Doolittlovu metodu, která zahrnuje diagonálu jedniček do dolní matice.

  Ne všechny matice mají LU rozklad, například `[0,1;1,0]` jej nemá a tato funkce v takovém případě vrátí `false` a nastaví `L` a `U` na `null`.

  Více informací najdete v encyklopediích Planetmath (text je v angličtině), Mathworld (text je v angličtině) a Wikipedia.

Minor

      Minor (M,i,j)

  Získat subdeterminant (též minor) `i`-`j` matice.

  Více informací najdete v encyklopedii Planetmath.

NonPivotColumns

      NonPivotColumns (M)

  Vrátit sloupce matice, které nemají pivot.

Norm

      Norm (v,p...)

  Alternativní názvy: `norm`

  Získat normu typu p (nebo typu 2, pokud není zadáno p) vektoru.

NullSpace

      NullSpace (T)

  Získat nulový prostor matice. Tj. jádro lineární transformace, která matici představuje. Výsledek se vrací v podobě matice, jejíž sloupcový prostor je nulovým prostorem z `T`.

  Více informací najdete v encyklopedii Planetmath (text je v angličtině).

Nullity

      Nullity (M)

  Alternativní názvy: `nullity`

  Získat nulovost matice. Tzn. vrátit rozměry nulového prostoru; rozměry jádra matice `M`.

  Více informací najdete v encyklopedii Planetmath (text je v angličtině).

OrthogonalComplement

      OrthogonalComplement (M)

  Získat ortogonální doplněk sloupcového prostoru.

PivotColumns

      PivotColumns (M)

  Vrátit sloupce matice s pivoty, tzn. sloupce, které mají 1 v řádkově redukované podobě. Rovněž vrací řádek, ve kterém se vyskytly.

Projection

      Projection (v,W,B...)

  Projekce vektoru `v` do podprostoru `W` vzhledem k unitárnímu prostoru danému `B`. Pokud `B` není zadáno, je použit standardní hermitovský součin. `B` může být buď polybilineární funkce dvou argumentů nebo to může být matice v polybilineární formě.

QRDecomposition

      QRDecomposition (A, Q)

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

      genius> R = QRDecomposition(A,&Q)

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

  Více informací najdete v encyklopediích Planetmath (text je v angličtině), Mathworld (text je v angličtině) a Wikipedia.

RayleighQuotient

      RayleighQuotient (A,x)

  Vrátit Rayleighův podíl (nazývaný také Rayleighův-Ritzův koeficient nebo podíl) matice a vektoru.

  Více informací najdete v encyklopedii Planetmath (text je v angličtině).

RayleighQuotientIteration

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

  Najít vlastní čísla matice `A` pomocí iterační metody Rayleighova podílu. `x` je odhadovaný vlastní vektor a mohl by být náhodný. Měl by mít nenulovou imaginární část, pokud existuje nějaká možnost, že budou nalezena komplexní vlastní čísla. Kód bude nanejvýše v `maxiter` iteracích a vracet `null`, pokud není možné získat výsledek v rámci chyby `epsilon`. `vecref` by měl být buď `null` nebo odkaz na proměnnou, do které by se měl uložit vlastní vektor.

  Více informací o Rayleighově podíle najdete v encyklopedii Planetmath (text je v angličtině).

Rank

      Rank (M)

  Alternativní názvy: `rank`

  Získat hodnost matice.

  Více informací najdete v encyklopedii Planetmath (text je v angličtině).

RosserMatrix

      RosserMatrix ()

  Vrátit Rosserovu matici, která je klasickým symetrickým problémem testu vlastního čísla.

Rotation2D

      Rotation2D (úhel)

  Alternativní názvy: `RotationMatrix`

  Vrátit matici odpovídající otočení okolo počátku v R2.

Rotation3DX

      Rotation3DX (úhel)

  Vrátit matici odpovídající otočení okolo počátku v R3 kolem osy x.

Rotation3DY

      Rotation3DY (úhel)

  Vrátit matici odpovídající otočení okolo počátku v R3 kolem osy y.

Rotation3DZ

      Rotation3DZ (úhel)

  Vrátit matici odpovídající otočení okolo počátku v R3 kolem osy z.

RowSpace

      RowSpace (M)

  Získat bázi matice pro prostor řádků matice.

SesquilinearForm

      SesquilinearForm (v,A,w)

  Vyhodnotit (v,w) vzhledem k polybilineární formě dané maticí `A`.

SesquilinearFormFunction

      SesquilinearFormFunction (A)

  Vrátit funkci vyhodnocující dva vektory vzhledem k polybilineární formě dané maticí `A`.

SmithNormalFormField

      SmithNormalFormField (A)

  Vrátit Smithův kanonický tvar (normální forma) matice nad poli (bude končit s jedničkami na diagonále).

  Více informací najdete v encyklopedii Wikipedia (článek je v angličtině).

SmithNormalFormInteger

      SmithNormalFormInteger (M)

  Vrátit Smithův kanonický tvar (normální formu) pro čtvercové celočíselné matice nad celými čísly.

  Více informací najdete v encyklopedii Wikipedia (článek je v angličtině).

SolveLinearSystem

      SolveLinearSystem (M,V,argumenty...)

  Vyřešit lineární systém Mx=V, vrátit řešení V, pokud existuje jedinečné řešení, jinak vrátit `null`. Je možné použít dva dodatečné parametry předávané odkazem, ve kterých získáte redukované M a V.

ToeplitzMatrix

      ToeplitzMatrix (s, r...)

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

  Více informací najdete v encyklopediích Wikipedia (text je v angličtině) a Planetmath (text je v angličtině).

Trace

      Trace (M)

  Alternativní názvy: `trace`

  Spočítat stopu matice. Jedná se o součet prvků na hlavní diagonále čtvercové matice.

  Více informací najdete v encyklopediích Wikipedia a Planetmath (text je v angličtině).

Transpose

      Transpose (M)

  Transponovat matici. Funkčně je to stejné, jako operátor `.'`.

  Více informací najdete v encyklopediích Wikipedia a Planetmath (text je v angličtině).

VandermondeMatrix

      VandermondeMatrix (v)

  Alternativní názvy: `vander`

  Vrátit Vandermondovu matici.

  Více informací najdete v encyklopedii Wikipedia.

VectorAngle

      VectorAngle (v,w,B...)

  Úhel dvou vektorů vzhledem k unitárnímu prostoru daného `B`. Pokud `B` není zadáno, je použit standardní hermitovský součin. `B` může být buď polybilineární funkce dvou argumentů nebo to může být matice v polybilineární formě.

VectorSpaceDirectSum

      VectorSpaceDirectSum (M,N)

  Přímý součet vektorových prostorů M a N.

VectorSubspaceIntersection

      VectorSubspaceIntersection (M,N)

  Průnik podprostorů daných pomocí M a N

VectorSubspaceSum

      VectorSubspaceSum (M,N)

  Součet vektorových prostorů M a N, tj. {w | w=m+n, m in M, n in N}.

adj

      adj (m)

  Alternativní názvy: `Adjugate`

  Získat adjungovanou (reciproku) matici.

cref

      cref (M)

  Aliases: `CREF` `ColumnReducedEchelonForm`

  Spočítat sloupcově odstupňovaný tvar matice.

det

      det (M)

  Alternativní názvy: `Determinant`

  Získat determinant matice.

  Více informací najdete v encyklopediích Planetmath (text je v angličtině) a Wikipedia.

ref

      ref (M)

  Aliases: `REF` `RowEchelonForm`

  Získat řádkově odstupňovaný tvar matice. To jest, použít Gaussovu eliminaci, ale bez zpětného dosazování do `M`. Nenulové řádky jsou poděleny, aby všechny pivoty byly 1.

  Více informací najdete v encyklopediích Wikipedia (text je v angličtině) a Planetmath (text je v angličtině).

rref

      rref (M)

  Aliases: `RREF` `ReducedRowEchelonForm`

  Získat redukovaný řádkově odstupňovaný tvar matice. To jest, použít Gaussovu eliminaci se zpětným dosazováním do `M`.

  Více informací najdete v encyklopediích Wikipedia (text je v angličtině) a Planetmath (text je v angličtině).

### Kombinatorika

Catalan

      Catalan (n)

  Získat `n`-té Catalanovo číslo.

  Více informací najdete v encyklopediích Planetmath (text je v angličtině) a Wikipedia.

Combinations

      Combinations (k,n)

  Získat jako vektor vektorů všechny kombinace k-té třídy z prvků 1 až n. (Viz také NextCombination)

  Více informací najdete v encyklopedii Wikipedia.

DoubleFactorial

      DoubleFactorial (n)

  Dvojitý faktoriál: `n(n-2)(n-4)…`

  Více informací najdete v encyklopedii Planetmath (text je v angličtině).

Factorial

      Factorial (n)

  Faktoriál: `n(n-1)(n-2)…`

  Více informací najdete v encyklopediích Planetmath (text je v angličtině) a Wikipedia.

FallingFactorial

      FallingFactorial (n,k)

  Klesající faktoriál: `(n)_k = n(n-1)…(n-(k-1))`

  Více informací najdete v encyklopedii Planetmath (text je v angličtině).

Fibonacci

      Fibonacci (x)

  Alternativní názvy: `fib`

  Vypočítat `n`-té Fibonacciho číslo. Tj. číslo definované rekurzivně jako `Fibonacci(n) = Fibonacci(n-1) + Fibonacci(n-2)` a `Fibonacci(1) = Fibonacci(2) = 1`.

  Více informací najdete v encyklopediích Planetmath (text je v angličtině), Mathworld (text je v angličtině) a Wikipedia.

FrobeniusNumber

      FrobeniusNumber (v,arg...)

  Spočítat Frobeniusovo číslo. Tzn. spočítat největší číslo, které nemůže být dáno jako lineární kombinace celých nezáporných čísel zadaných jako vektor nezáporných celých čísel. Vektor může být zadán jako samostatná čísla nebo jeden vektor. Všechna zadaná čísla by měla mít největšího společného dělitele 1.

  Více informací najdete v encyklopediích Wikipedia (text je v angličtině) a Mathworld (text je v angličtině).

GaloisMatrix

      GaloisMatrix (kombinacni_pravidlo)

  Galoisova matice daná lineárním kombinačním pravidlem (a_1*x_1+…+a_n*x_n=x_(n+1)).

GreedyAlgorithm

      GreedyAlgorithm (n,v)

  Najít takový vektor `c` nezáporných celých čísel, že skalární součin s `v` je roven `n`. Když to není možné, vrátí `null`. Vektor `v` by měl být předán seřazený ve vzestupném pořadí a měl by se skládat z nezáporných celých čísel.

  Více informací najdete v encyklopediích Mathworld (text je v angličtině) a Wikipedia.

HarmonicNumber

      HarmonicNumber (n,r)

  Alternativní názvy: `HarmonicH`

  Harmonické číslo, `n`-té harmonické číslo řádu `r`. Jedná se o součet `1/k^r` pro `k` od 1 do n. Je to to stejné jako `sum k = 1 to n do 1/k^r`.

  Více informací najdete v encyklopedii Wikipedia (text je v angličtině).

Hofstadter

      Hofstadter (n)

  Hofstadterova funkce q(n) definovaná jako q(1)=1, q(2)=1, q(n)=q(n-q(n-1))+q(n-q(n-2))

  Více informací najdete v encyklopedii Wikipedia (text je v angličtině). Posloupnost je A005185 podle encyklopedie OEIS.

LinearRecursiveSequence

      LinearRecursiveSequence (pocatecni_hodnoty,kombinacni_pravidlo,n)

  Spočítat lineární rekurzivní posloupnost pomocí Galoisova krokování.

Multinomial

      Multinomial (v,arg...)

  Spočítat multinomické koeficienty. Přebírá vektor `k` nezáporných celých čísel a spočítá multinomický koeficient. To odpovídá koeficientu v homogenním polynomu v `k` proměnných s odpovídajícími mocninami.

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

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

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

  Více informací najdete v encyklopediích Planetmath (text je v angličtině), Mathworld (text je v angličtině) a Wikipedia.

NextCombination

      NextCombination (v,n)

  Získat kombinaci, která by následovala po kombinaci `v` v pořadí kombinací, první kombinací by měla být `[1:k]`. To je užitečné, pokud máte hodně kombinací, které chcete projít a nechcete plýtvat pamětí na uložení všech.

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

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

  But with NextCombination you would write something like:

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

  See also Combinations.

  Více informací najdete v encyklopedii Wikipedia.

Pascal

      Pascal (i)

  Získat Pascalův trojúhelník v podobě matice. Vrátí dolní trojúhelníkovou matici `i`+1 krát `i`+1, která je Pascalovým trojúhelníkem po `i` iteracích.

  Více informací najdete v encyklopediích Planetmath (text je v angličtině) a Wikipedia.

Permutations

      Permutations (k,n)

  Získat jako vektor vektorů všechny variace `k`-té třídy z prvků 1 až `n` prvků, případně permutace pro `k`=`n`.

  Více informací najdete v encyklopediích Mathworld (text je v angličtině) nebo Wikipedia (permutace) a Wikipedia (variace).

RisingFactorial

      RisingFactorial (n,k)

  Alternativní názvy: `Pochhammer`

  (Pochhammerův) stoupacící faktoriál: (n)_k = n(n+1)…(n+(k-1))

  Více informací najdete v encyklopedii Planetmath (text je v angličtině).

StirlingNumberFirst

      StirlingNumberFirst (n,m)

  Alternativní názvy: `StirlingS1`

  Stirlingovo číslo prvního druhu.

  Více informací najdete v encyklopediích Planetmath (text je v angličtině) nebo Mathworld (text je v angličtině).

StirlingNumberSecond

      StirlingNumberSecond (n,m)

  Alternativní názvy: `StirlingS2`

  Stirlingovo číslo druhého druhu.

  Více informací najdete v encyklopediích Planetmath (text je v angličtině) nebo Mathworld (text je v angličtině).

Subfactorial

      Subfactorial (n)

  Subfaktoriál: n! krát suma_{k=0}^n (-1)^k/k!

Triangular

      Triangular (n)

  Spočítat `n`-té trojúhelníkové číslo.

  Více informací najdete v encyklopediích Planetmath (text je v angličtině) a Wikipedia.

nCr

      nCr (n,r)

  Alternativní názvy: `Binomial`

  Spočítat kombinace, tj. kombinační číslo. `n` může být libovolné reálné číslo.

  Více informací najdete v encyklopediích Planetmath (text je v angličtině) a Wikipedia.

nPr

      nPr (n,k)

  Spočítat počet variací `k`-té třídy z prvků 1 až `n`, respektive počet permutací při `k` rovno `n`.

  Více informací najdete v encyklopediích Mathworld (text je v angličtině) nebo Wikipedia (permutace) a Wikipedia (variace).

### Diferenciální/integrální počet

AdaptiveGaussKronrod

      AdaptiveGaussKronrod (f,a,b)

  Find the integral of `f` over the interval [a,b] using an adaptive algorithm using Gauss-Kronrod rule G7 K15. It will subdivide adaptively until the relative error is less than `AdaptiveGaussKronrodRelativeTolerance` or the absolute error is within `AdaptiveGaussKronrodAbsoluteTolerance`. The subinterval with the largest error is subdivided into two until we get a small enough error or until we hit `AdaptiveGaussKronrodMaxIterations` iterations.

  If an estimate within the given range is not achieved within the iteration limit, then `null` is returned and error is printed.

  See Wikipedia for more information.

  Version 1.0.28 onwards.

AdaptiveGaussKronrodWithTolerance

      AdaptiveGaussKronrod (f,a,b,abstol,reltol)

  Find the integral of `f` over the interval [a,b] using an adaptive algorithm using Gauss-Kronrod rule G7 K15. It will subdivide adaptively until the relative error is less than `abstol` or the absolute error is within `reltol`. The subinterval with the largest error is subdivided into two until we get a small enough error or until we hit `AdaptiveGaussKronrodMaxIterations` iterations.

  If an estimate within the given range is not achieved within the iteration limit, then `null` is returned and error is printed.

  This function is useful if different precision than the defaults is needed and one does not want to change global parameters. For example, if less precision is needed and speed is paramount. Otherwise just use `AdaptiveGaussKronrod` or `NumericalIntegral`

  See Wikipedia for more information.

  Version 1.0.28 onwards.

CompositeSimpsonsRule

      CompositeSimpsonsRule (f,a,b,n)

  Integration of `f` by Composite 1/3 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. If the given `n` is odd, then 1 is added to make it even.

  It is the 1/3 variant of the rule that is used, that is, if the x0,x1,x2,...,xn are the points, then the rule is ((b-a)/n) * (f(x0) + 4*f(x1) + 2*f(x2) + ... + 4*f(x(n-1)) + f(xn)).

  The `n` argument is optional. If it is not given the value of `NumericalIntegralSteps` is used, which is by default 1000.

  See Wikipedia or Planetmath for more information.

CompositeSimpsonsRuleData

      CompositeSimpsonsRule (f,len)

  Integration using Composite Simpson's rule of a function given by a vector of values `f` given at equal subintervals. The integration interval is taken to be of length `len`, that is, if the interval is [a,b], then `len` should be b-a. The vector `f` should have at least 3 values (representing 2 subintervals). Normally the 1/3 rule is used. If there is an odd number of subintervals, the 3/8 rule is used on the last 3 subintervals.

  See Wikipedia or Planetmath for more information.

  Version 1.0.28 onwards.

CompositeSimpsonsRuleTolerance

      CompositeSimpsonsRuleTolerance (f,a,b,omezeni_ctvrte_derivace,tolerance)

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

  See Wikipedia or Planetmath for more information.

Derivative

      Derivative (f,x0)

  Zkusit spočítat derivaci, nejprve symbolicky a pak numericky.

  Více informací najdete v encyklopedii Wikipedia.

EvenPeriodicExtension

      EvenPeriodicExtension (f,L)

  Vrátit funkci, která je sudým periodickým rozšířením `f` s poloviční periodou `L`. Tj. funkce definovaná na intervalu `[0,L]` rozšířená, aby byla sudá na `[-L,L]` a pak rozšířená, aby byla periodická s periodou `2*L`.

  Viz také OddPeriodicExtension a PeriodicExtension.

  Verze 1.0.7 a novější.

FourierSeriesFunction

      FourierSeriesFunction (a,b,L)

  Vrátit funkci, která je Fourierovu řadou s koeficienty danými vektory `a` (sinové) a `b` (kosinové). Vezměte na vědomí, že `a@(1)` je konstantní koeficient! To znamená, že `a@(n)` odkazuje na člen `cos(x*(n-1)*pi/L)`, zatímco `b@(n)` odkazuje na člen `sin(x*n*pi/L)`. Buďto `a` nebo `b` může být `null`.

  Více informací najdete v encyklopediích Mathworld (text je v angličtině) nebo Wikipedia.

GaussKronrodRule

      GaussKronrodRule (f,a,b)

  A single shot Gauss-Kronrod rule G7 K15 over the interval [a,b]. It returns a vector where the first element is the approximate integral and the second is the approximate error obtained by subtracting the G7 and K15 approximates. This is already quite good, but often it is better to call it from within the `AdaptiveGaussKronrod` function, which is the default for `NumericalIntegral`.

  See Wikipedia for more information.

  Version 1.0.28 onwards.

InfiniteProduct

      InfiniteProduct (fce,start,prirustek)

  Zkusit spočítat nekonečný součin funkce s jedním parametrem.

InfiniteProduct2

      InfiniteProduct2 (fce,arg,start,prirustek)

  Zkusit spočítat nekonečný součin funkce se dvěma parametry s fce (arg,n).

InfiniteSum

      InfiniteSum (fce,start,prirustek)

  Zkusit spočítat nekonečný součet funkce s jedním parametrem.

InfiniteSum2

      InfiniteSum2 (fce,arg,start,prirustek)

  Zkusit spočítat nekonečný součet funkce se dvěma parametry s fce (arg,n).

IsContinuous

      IsContinuous (f,x0)

  Zkusit zjistit pomocí výpočtu limity v x0, jestli je funkce reálné proměnné v tomto bodě spojitá.

IsDifferentiable

      IsDifferentiable (f,x0)

  Otestovat na diferencovatelnost aproximací limit zleva a zprava a porovnáním.

LeftHandRule

      LeftHandRule (f,a,b,n)

  Integration by left hand rule on the interval [a,b] with n subintervals.

  The `n` argument is optional. If it is not given the value of `NumericalIntegralSteps` is used, which is by default 1000.

  Version 1.0.28 onwards.

LeftLimit

      LeftLimit (f,x0)

  Spočítat limitu zleva funkce reálné proměnné v x0.

Limit

      Limit (f,x0)

  Spočítat limitu funkce reálné proměnné v x0. Zkusí vypočítat limitu zleva i zprava.

MidpointRule

      MidpointRule (f,a,b,n)

  Integration by midpoint rule on the interval [a,b] with n subintervals.

  The `n` argument is optional. If it is not given the value of `NumericalIntegralSteps` is used, which is by default 1000.

  The `n` is optional for version 1.0.28 onwards.

NumericalDerivative

      NumericalDerivative (f,x0)

  Alternativní názvy: `NDerivative`

  Zkusit vypočítat numerickou derivaci.

  Více informací najdete v encyklopedii Wikipedia.

NumericalFourierSeriesCoefficients

      NumericalFourierSeriesCoefficients (f,L,N)

  Vrátit vektor vektorů `[a,b]`, kde `a` jsou kosinové koeficienty a `b` sinové koeficienty Fourierovy řady funkce `f` s poloviční periodou `L` (tj. definovanou na `[-L,L]` a periodicky rozšířenou) s numericky spočítanými koeficienty do `N`-té harmonické. Koeficienty jsou spočítány numerickou integrací pomocí `NumericalIntegral`.

  Více informací najdete v encyklopediích Mathworld (text je v angličtině) nebo Wikipedia.

  Verze 1.0.7 a novější.

NumericalFourierSeriesFunction

      NumericalFourierSeriesFunction (f,L,N)

  Vrátit funkci, která je Fourierovou řadou funkce `f` s poloviční periodou `L` (tj. definovanou na `[-L,L]` a periodicky rozšířenou) s numericky spočítanými koeficienty do `N`-té harmonické. Jde o čistě trigonometrickou řadu složenou ze sinů a kosinů. Koeficienty jsou spočítány numerickou integrací pomocí `NumericalIntegral`.

  Více informací najdete v encyklopediích Mathworld (text je v angličtině) nebo Wikipedia.

  Verze 1.0.7 a novější.

NumericalFourierCosineSeriesCoefficients

      NumericalFourierCosineSeriesCoefficients (f,L,N)

  Vrátit vektor koeficientů kosinové Fourierovy řady funkce `f` s poloviční periodou `L`. To jest, vezmeme funkci `f` definovanou na `[0,L]`, provedeme sudé periodické rozšíření a spočteme Fourierovu řadu, která má pouze kosinové členy. Řada je spočítána do `N`-té harmonické. Koeficienty jsou spočítány numerickou integrací pomocí `NumericalIntegral`. Poznamenejme, že `a@(1)` je konstantní koeficient! To znamená, že `a@(n)` odkazuje na člen `cos(x*(n-1)*pi/L)`.

  Více informací najdete v encyklopediích Mathworld (text je v angličtině) nebo Wikipedia.

  Verze 1.0.7 a novější.

NumericalFourierCosineSeriesFunction

      NumericalFourierCosineSeriesFunction (f,L,N)

  Vrátit funkci, která je kosinovou Fourierovu řadou funkce `f` s poloviční periodou `L`. To jest, vezmeme funkci `f` definovanou na `[0,L]`, provedeme sudé periodické rozšíření a spočteme Fourierovu řadu, která má pouze kosinové členy. Řada je spočítána do `N`-té harmonické. Koeficienty jsou spočítány numerickou integrací pomocí `NumericalIntegral`.

  Více informací najdete v encyklopediích Mathworld (text je v angličtině) nebo Wikipedia.

  Verze 1.0.7 a novější.

NumericalFourierSineSeriesCoefficients

      NumericalFourierSineSeriesCoefficients (f,L,N)

  Vrátit vektor koeficientů sinové Fourierovy řady funkce `f` s poloviční periodou `L`. To jest, vezmeme funkci `f` definovanou na `[0,L]`, provedeme liché periodické rozšíření a spočteme Fourierovu řadu, která má pouze sinové členy. Řada je spočítána do `N`-té harmonické. Koeficienty jsou spočítány numerickou integrací pomocí `NumericalIntegral`.

  Více informací najdete v encyklopediích Mathworld (text je v angličtině) nebo Wikipedia.

  Verze 1.0.7 a novější.

NumericalFourierSineSeriesFunction

      NumericalFourierSineSeriesFunction (f,L,N)

  Vrátit funkci, která je sinovou Fourierovu řadou funkce `f` s poloviční periodou `L`. To jest, vezmeme funkci `f` definovanou na `[0,L]`, provedeme liché periodické rozšíření a spočteme Fourierovu řadu, která má pouze sinové členy. Řada je spočítána do `N`-té harmonické. Koeficienty jsou spočítány numerickou integrací pomocí `NumericalIntegral`.

  Více informací najdete v encyklopediích Mathworld (text je v angličtině) nebo Wikipedia.

  Verze 1.0.7 a novější.

NumericalIntegral

      NumericalIntegral (f,a,b)

  Integration by rule set in NumericalIntegralFunction of f from a to b. By default NumericalIntegralFunction is the `AdaptiveGaussKronrod`, which implements an adaptive algorithm based on the Gauss-Kronrod G7 K15 rule. It is possible that `null` is returned if the algorithm cannot find an approximation within tolerance in a tunable maximum number of iterations.

  Gauss-Kronrod is the default algorithm since version 1.0.28 onwards.

NumericalLeftDerivative

      NumericalLeftDerivative (f,x0)

  Zkusit vypočítat numerickou levou derivaci.

NumericalLimitAtInfinity

      NumericalLimitAtInfinity (_f,step_fun,tolerance,serie_pro_uspech,N)

  Pokusit se spočítat limitu f(step_fun(i)) pro i od 1 do N.

NumericalRightDerivative

      NumericalRightDerivative (f,x0)

  Zkusit vypočítat numerickou pravou derivaci.

OddPeriodicExtension

      OddPeriodicExtension (f,L)

  Vrátit funkci, která je lichým periodickým rozšířením `f` s poloviční periodou `L`. Tj. funkce definovaná na intervalu `[0,L]` rozšířená, aby byla lichá na `[-L,L]` a pak rozšířená, aby byla periodická s periodou `2*L`.

  Viz také EvenPeriodicExtension a PeriodicExtension.

  Verze 1.0.7 a novější.

OneSidedFivePointFormula

      OneSidedFivePointFormula (f,x0,h)

  Spočítat jednostrannou derivaci pomocí pětibodového vzorce.

OneSidedThreePointFormula

      OneSidedThreePointFormula (f,x0,h)

  Spočítat jednostrannou derivaci pomocí tříbodového vzorce.

PeriodicExtension

      PeriodicExtension (f,a,b)

  Vrátit funkci, která je periodickým rozšířením `f` definované na intervalu `[a,b]` a s periodou `b-a`.

  Viz také OddPeriodicExtension a EvenPeriodicExtension.

  Verze 1.0.7 a novější.

RightHandRule

      RightHandRule (f,a,b,n)

  Integration by right hand rule on the interval [a,b] with n subintervals.

  The `n` argument is optional. If it is not given the value of `NumericalIntegralSteps` is used, which is by default 1000.

  Version 1.0.28 onwards.

RightLimit

      RightLimit (f,x0)

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

TrapezoidRule

      TrapezoidRule (f,a,b,n)

  Integration by trapezoid rule on the interval [a,b] with `n` subintervals.

  The `n` argument is optional. If it is not given the value of `NumericalIntegralSteps` is used, which is by default 1000.

  Version 1.0.28 onwards.

TwoSidedFivePointFormula

      TwoSidedFivePointFormula (f,x0,h)

  Spočítat oboustrannou derivaci pomocí pětibodového vzorce.

TwoSidedThreePointFormula

      TwoSidedThreePointFormula (f,x0,h)

  Spočítat oboustrannou derivaci pomocí tříbodového vzorce.

### Funkce

Argument

      Argument (z)

  Aliases: `Arg` `arg`

  argument (angle) of complex number. It is in the range (-pi,pi].

BesselJ0

      BesselJ0 (x)

  Besselova funkce prvního druhu řádu 0. Je implementována pouze pro reálná čísla.

  Více informací najdete v encyklopedii Wikipedia.

  Verze 1.0.16 a novější.

BesselJ1

      BesselJ1 (x)

  Besselova funkce prvního druhu řádu 1. Je implementována pouze pro reálná čísla.

  Více informací najdete v encyklopedii Wikipedia.

  Verze 1.0.16 a novější.

BesselJn

      BesselJn (n,x)

  Besselova funkce prvního druhu řádu `n`. Je implementována pouze pro reálná čísla.

  Více informací najdete v encyklopedii Wikipedia.

  Verze 1.0.16 a novější.

BesselY0

      BesselY0 (x)

  Besselova funkce druhého druhu řádu 0. Je implementována pouze pro reálná čísla.

  Více informací najdete v encyklopedii Wikipedia.

  Verze 1.0.16 a novější.

BesselY1

      BesselY1 (x)

  Besselova funkce druhého druhu řádu 1. Je implementována pouze pro reálná čísla.

  Více informací najdete v encyklopedii Wikipedia.

  Verze 1.0.16 a novější.

BesselYn

      BesselYn (n,x)

  Besselova funkce druhého druhu řádu `n`. Je implementována pouze pro reálná čísla.

  Více informací najdete v encyklopedii Wikipedia.

  Verze 1.0.16 a novější.

DirichletKernel

      DirichletKernel (n,t)

  Dirichletovo jádro řádu `n`.

DiscreteDelta

      DiscreteDelta (v)

  Vrátit 1, když a jen když jsou všechny prvky nulové.

ErrorFunction

      ErrorFunction (x)

  Alternativní názvy: `erf`

  Chybová funkce, 2/sqrt(pi) * int_0^x e^(-t^2) dt.

  Více informací najdete v encyklopediích Planetmath (text je v angličtině) a Wikipedia.

FejerKernel

      FejerKernel (n,t)

  Fejerovo jádro řádu `n` vyhodnocené v `t`.

  Více informací najdete v encyklopedii Planetmath (text je v angličtině).

GammaFunction

      GammaFunction (x)

  Alternativní názvy: `Gamma`

  Funkce Gama. V současnosti je implementována pouze pro reálná čísla.

  Více informací najdete v encyklopediích Planetmath (text je v angličtině) a Wikipedia.

KroneckerDelta

      KroneckerDelta (v)

  Vrátit 1, když a jen když se všechny prvky rovnají.

LambertW

      LambertW (x)

  Hlavní větev Lambertovy funkce W vypočítaná pro čistě reálná čísla větší nebo rovna `-1/e`. Funkce `LambertW` je inverzní k výrazu `x*e^x`. Dokonce i pro reálná `x` tento výraz není jedna k jedné a proto má dvě větve pro `[-1/e,0)`. Viz `LambertWm1` ohledně další reálné větve.

  Více informací najdete v encyklopedii Wikipedia (text je v angličtině).

  Verze 1.0.18 a novější.

LambertWm1

      LambertWm1 (x)

  Vedlejší (mínus první) větev Lambertovy funkce W vypočítaná pro čistě reálná čísla větší nebo rovna `-1/e`. Funkce `LambertWm1` je druhou větví k inverzi výrazu `x*e^x`. Viz `LambertW` ohledně hlavní větve.

  Více informací najdete v encyklopedii Wikipedia (text je v angličtině).

MinimizeFunction

      MinimizeFunction (fce,x,prirust)

  Najít první hodnotu, kdy f(x)=0.

MoebiusDiskMapping

      MoebiusDiskMapping (a,z)

  Möbiova transformace (lineární lomené zobrazení) kruhu na sebe sama ku 0.

  Více informací najdete v encyklopediích Wikipedia (text je v angličtině) a Planetmath (text je v angličtině).

MoebiusMapping

      MoebiusMapping (z,z2,z3,z4)

  Möbiova transformace (lineární lomené zobrazení) pomocí dvojpoměrů z2,z3,z4 ku 1,0 a nekonečnu.

  Více informací najdete v encyklopediích Wikipedia (text je v angličtině) a Planetmath (text je v angličtině).

MoebiusMappingInftyToInfty

      MoebiusMappingInftyToInfty (z,z2,z3)

  Möbiova transformace (lineární lomené zobrazení) pomocí dvojpoměrů nekonečna ku nekonečnu a z2,z3 ku 1 a 0.

  Více informací najdete v encyklopediích Wikipedia (text je v angličtině) a Planetmath (text je v angličtině).

MoebiusMappingInftyToOne

      MoebiusMappingInftyToOne (z,z3,z4)

  Möbiova transformace (lineární lomené zobrazení) pomocí dvojpoměrů nekonečna ku 1 a z3,z4 ku 0 a nekonečnu.

  Více informací najdete v encyklopediích Wikipedia (text je v angličtině) a Planetmath (text je v angličtině).

MoebiusMappingInftyToZero

      MoebiusMappingInftyToZero (z,z2,z4)

  Möbiova transformace (lineární lomené zobrazení) pomocí dvojpoměrů nekonečna ku 0 a z2,z4 ku 1 a nekonečnu.

  Více informací najdete v encyklopediích Wikipedia (text je v angličtině) a Planetmath (text je v angličtině).

PoissonKernel

      PoissonKernel (r,sigma)

  Poissonovo jádro na D(0,1) (nenormalizované na 1, tj. integrál je 2pi).

PoissonKernelRadius

      PoissonKernelRadius (r,sigma)

  Poissonovo jádro na D(0,R) (nenormalizované na 1).

RiemannZeta

      RiemannZeta (x)

  Alternativní názvy: `zeta`

  Riemannova funkce zeta. V současnosti je implementována jen pro reálná čísla.

  Více informací najdete v encyklopediích Planetmath (text je v angličtině) a Wikipedia.

UnitStep

      UnitStep (x)

  Funkce jednotkového skoku je rovna 0 pro x<0 a jedné v ostatních případech. Jedná se o integrál Diracovy funkce delta. Bývá také nazývána Heavisideova funkce.

  Více informací najdete v encyklopedii Wikipedia.

cis

      cis (x)

  Funkce `cis`, což je to stejné jako `cos(x)+1i*sin(x)`

deg2rad

      deg2rad (x)

  Převést stupně na radiány.

rad2deg

      rad2deg (x)

  Převést radiány na stupně.

sinc

      sinc (x)

  Vypočítat nenormalizovanou funkci sinc, což je `sin(x)/x`. Jestli chcete normalizovanou funkci, volejte `sinc(pi*x)`.

  Více informací najdete v encyklopedii Wikipedia.

  Verze 1.0.16 a novější.

### Řešení rovnic

CubicFormula

      CubicFormula (p)

  Vypočítat kořeny kubického (3. stupně) polynomu pomocí kubické rovnice. Polynom by měl být zadán jako vektor koeficientů. Tj. `4*x^3 + 2*x + 1` odpovídá vektoru `[1,2,0,4]`. Vrací sloupcový vektor tří řešení. První řešení je vždy reálné, protože kubická rovnice má vždy jedno reálné řešení.

  Více informací najdete v encyklopediích Planetmath (text je v angličtině), Mathworld (text je v angličtině) a Wikipedia.

EulersMethod

      EulersMethod (f,x0,y0,x1,n)

  Použít klasickou Eulerovu metodu k numerickému řešení y'=f(x,y) pro počáteční `x0`, `y0` měnící se do `x1` s přírůstky `n` a vrátit `y` v `x1`. Pokud nechcete výslovně použít Eulerovu metodu, měli byste vážně popřemýšlet o použití RungeKutta k řešení obyčejných diferenciálních rovnic.

  Systémy je možné vyřešit jednoduše tak, že `y` musí být všude (sloupcový) vektor. To znamená, že `y0` může být vektor v případech, kdy by `f` mělo přebírat `x` a vektor stejné velikosti pro druhý argument a mělo by vracet vektor stejné velikosti.

  Více informací najdete v encyklopediích Mathworld (text je v angličtině) a Wikipedia.

EulersMethodFull

      EulersMethodFull (f,x0,y0,x1,n)

  Použít klasickou Eulerovu metodu k numerickému řešení y'=f(x,y) pro počáteční `x0`, `y0` měnící se do `x1` s přírůstky `n` a vrátit matici `n+1` krát 2 s hodnotami `x` a `y`. Pokud nechcete výslovně použít Eulerovu metodu, měli byste vážně popřemýšlet o použití RungeKuttaFull k řešení obyčejných diferenciálních rovnic. Vhodné pro zapojení do LinePlotDrawLine nebo LinePlotDrawPoints.

  Example:

      genius> LinePlotClear();
      genius> line = EulersMethodFull(`(x,y)=y,0,1.0,3.0,50);
      genius> LinePlotDrawLine(line,"window","fit","color","blue","legend","Exponential growth");

  Systémy je možné vyřešit jednoduše tak, že `y` musí být všude (sloupcový) vektor. To znamená, že `y0` může být vektor v případech, kdy by `f` mělo přebírat `x` a vektor stejné velikosti pro druhý argument a mělo by vracet vektor stejné velikosti.

  The output for a system is still a n by 2 matrix with the second entry being a vector. If you wish to plot the line, make sure to use row vectors, and then flatten the matrix with ExpandMatrix, and pick out the right columns. Example:

      genius> LinePlotClear();
      genius> lines = EulersMethodFull(`(x,y)=[y@(2),-y@(1)],0,[1.0,1.0],10.0,500);
      genius> lines = ExpandMatrix(lines);
      genius> firstline = lines@(,[1,2]);
      genius> secondline = lines@(,[1,3]);
      genius> LinePlotWindow = [0,10,-2,2];
      genius> LinePlotDrawLine(firstline,"color","blue","legend","First");
      genius> LinePlotDrawPoints(secondline,"color","red","thickness",3,"legend","Second");

  Více informací najdete v encyklopediích Mathworld (text je v angličtině) a Wikipedia.

  Verze 1.0.10 a novější.

FindRootBisection

      FindRootBisection (f,a,b,TOL,N)

  Najít kořen funkce pomocí metody bisekce. `a` a `b` je počáteční odhad intervalu, `f(a)` a `f(b)` by měly mít opačná znaménka. `TOL` je požadovaná tolerance a `N` je omezení počtu iterací, které mají proběhnout, 0 značí bez omezení. Funkce vrací vektor `[uspech,hodnota,iteratce]`, kde `uspech` je pravdivostní hodnota signalizující úspěch, `hodnota` je poslední spočtená hodnota a `iterace` je počet dokončených iterací.

FindRootFalsePosition

      FindRootFalsePosition (f,a,b,TOL,N)

  Najít kořen funkce pomocí metody tětiv. `a` a `b` je počáteční odhad intervalu, `f(a)` a `f(b)` by měly mít opačná znaménka. `TOL` je požadovaná tolerance a `N` je omezení počtu iterací, které mají proběhnout, 0 značí bez omezení. Funkce vrací vektor `[uspech,hodnota,iteratce]`, kde `uspech` je pravdivostní hodnota signalizující úspěch, `hodnota` je poslední spočtená hodnota a `iterace` je počet dokončených iterací.

FindRootMullersMethod

      FindRootMullersMethod (f,x0,x1,x2,TOL,N)

  Najít kořen funkce pomocí Mullerovy metody. `TOL` je požadovaná tolerance a `N` je omezení počtu iterací, které mají proběhnout, 0 značí bez omezení. Funkce vrací vektor `[uspech,hodnota,iteratce]`, kde `uspech` je pravdivostní hodnota signalizující úspěch, `hodnota` je poslední spočtená hodnota a `iterace` je počet dokončených iterací.

FindRootSecant

      FindRootSecant (f,a,b,TOL,N)

  Najít kořen funkce pomocí metody sečen. `a` a `b` je počáteční odhad intervalu, `f(a)` a `f(b)` by měly mít opačná znaménka. `TOL` je požadovaná tolerance a `N` je omezení počtu iterací, které mají proběhnout, 0 značí bez omezení. Funkce vrací vektor `[uspech,hodnota,iteratce]`, kde `uspech` je pravdivostní hodnota signalizující úspěch, `hodnota` je poslední spočtená hodnota a `iterace` je počet dokončených iterací.

HalleysMethod

      HalleysMethod (f,df,ddf,odhad,epsilon,maxn)

  Najde nuly pomocí Halleyovy metody. `f` je funkce, `df` je její derivace a `ddf` její druhá derivace. `odhad` je počáteční odhad. Funkce vrací výsledek po dvou úspěšných hodnotách, které každá spadají do `epsilon` nebo po `maxn` pokusech, v kterémžto případě vrací `null`, což značí selhání.

  Viz také `NewtonsMethod` a `SymbolicDerivative`.

  Example to find the square root of 10:

      genius> HalleysMethod(`(x)=x^2-10,`(x)=2*x,`(x)=2,3,10^-10,100)

  Více informací najdete v encyklopedii Wikipedia (text je v angličtině).

  Verze 1.0.18 a novější.

NewtonsMethod

      NewtonsMethod (f,df,odhad,epsilon,maxn)

  Najde nuly pomocí metody tečen (Newtonovy metody). `f` je funkce a `df` je její derivace. `odhad` je počáteční odhad. Funkce vrací výsledek po dvou úspěšných hodnotách, které každá spadají do `epsilon` nebo po `maxn` pokusech, v kterémžto případě vrací `null`, což značí selhání.

  Viz také `NewtonsMethodPoly` a `SymbolicDerivative`.

  Example to find the square root of 10:

      genius> NewtonsMethod(`(x)=x^2-10,`(x)=2*x,3,10^-10,100)

  Více informací najdete v encyklopedii Wikipedia.

  Verze 1.0.18 a novější.

PolynomialRoots

      PolynomialRoots (p)

  Vypočítat kořeny polynomu (1. až 4. stupně) pomocí jedné z rovnic pro takovéto polynomy. Polynom by měl být zadán jako vektor koeficientů. Tj. `4*x^3 + 2*x + 1` odpovídá vektoru `[1,2,0,4]`. Vrací sloupcový vektor řešení.

  Funkce volá QuadraticFormula, CubicFormula a QuarticFormula.

QuadraticFormula

      QuadraticFormula (p)

  Vypočítat kořeny kvadratického (2. stupně) polynomu pomocí kvadratické rovnice. Polynom by měl být zadán jako vektor koeficientů. Tj. `3*x^2 + 2*x + 1` odpovídá vektoru `[1,2,3]`. Vrací sloupcový vektor dvou řešení.

  Více informací najdete v encyklopediích Planetmath (text je v angličtině), Mathworld (text je v angličtině) a Wikipedia (text je v angličtině).

QuarticFormula

      QuarticFormula (p)

  Vypočítat kořeny kvartického (4. stupně) polynomu pomocí kvartické rovnice. Polynom by měl být zadán jako vektor koeficientů. Tj. `5*x^4 + 2*x + 1` odpovídá vektoru `[1,2,0,0,5]`. Vrací sloupcový vektor čtyř řešení.

  Více informací najdete v encyklopediích Planetmath (text je v angličtině), Mathworld (text je v angličtině) a Wikipedia (text je v angličtině).

RungeKutta

      RungeKutta (f,x0,y0,x1,n)

  Použít klasickou neadaptivní Rungeho-Kuttovu metodu čtvrtého řádu k numerickému řešení y'=f(x,y) pro počáteční `x0`, `y0` měnící se do `x1` s přírůstky `n`, vrací `y` v `x1`.

  Systémy je možné vyřešit jednoduše tak, že `y` musí být všude (sloupcový) vektor. To znamená, že `y0` může být vektor v případech, kdy by `f` mělo přebírat `x` a vektor stejné velikosti pro druhý argument a mělo by vracet vektor stejné velikosti.

  Více informací najdete v encyklopediích Mathworld (text je v angličtině) a Wikipedia.

RungeKuttaFull

      RungeKuttaFull (f,x0,y0,x1,n)

  Použít klasickou neadaptivní metodu Runge-Kutta čtvrtého řádu k numerickému řešení y'=f(x,y) pro počáteční `x0`, `y0` měnící se do `x1` s přírůstky `n` a vrátit matici `n+1` krát 2 s hodnotami `x` a `y`. Vhodné pro zapojení do LinePlotDrawLine nebo LinePlotDrawPoints.

  Example:

      genius> LinePlotClear();
      genius> line = RungeKuttaFull(`(x,y)=y,0,1.0,3.0,50);
      genius> LinePlotDrawLine(line,"window","fit","color","blue","legend","Exponential growth");

  Systémy je možné vyřešit jednoduše tak, že `y` musí být všude (sloupcový) vektor. To znamená, že `y0` může být vektor v případech, kdy by `f` mělo přebírat `x` a vektor stejné velikosti pro druhý argument a mělo by vracet vektor stejné velikosti.

  The output for a system is still a n by 2 matrix with the second entry being a vector. If you wish to plot the line, make sure to use row vectors, and then flatten the matrix with ExpandMatrix, and pick out the right columns. Example:

      genius> LinePlotClear();
      genius> lines = RungeKuttaFull(`(x,y)=[y@(2),-y@(1)],0,[1.0,1.0],10.0,100);
      genius> lines = ExpandMatrix(lines);
      genius> firstline = lines@(,[1,2]);
      genius> secondline = lines@(,[1,3]);
      genius> LinePlotWindow = [0,10,-2,2];
      genius> LinePlotDrawLine(firstline,"color","blue","legend","First");
      genius> LinePlotDrawPoints(secondline,"color","red","thickness",3,"legend","Second");

  Více informací najdete v encyklopediích Mathworld (text je v angličtině) a Wikipedia.

  Verze 1.0.10 a novější.

### Statistika

Average

      Average (m)

  Aliases: `average` `Mean` `mean`

  Vypočítat průměr (aritmetickou střední hodnotu) z celé matice.

  Více informací najdete v encyklopediích Mathworld (text je v angličtině) a Wikipedia (text je v angličtině).

GaussDistribution

      GaussDistribution (x,sigma)

  Integrál Gaussovy funkce od 0 do `x` (oblast pod normální křivkou).

  Více informací najdete v encyklopediích Mathworld (text je v angličtině) a Wikipedia.

GaussFunction

      GaussFunction (x,sigma)

  Normalizovaného Gaussova funkce rozdělení (normální křivka).

  Více informací najdete v encyklopediích Mathworld (text je v angličtině) a Wikipedia.

Median

      Median (m)

  Alternativní názvy: `median`

  Vypočítat medián z celé matice.

  Více informací najdete v encyklopediích Mathworld (text je v angličtině) a Wikipedia.

PopulationStandardDeviation

      PopulationStandardDeviation (m)

  Alternativní názvy: `stdevp`

  Spočítat standardní odchylku souboru celé matice.

RowAverage

      RowAverage (m)

  Alternativní názvy: `RowMean`

  Vypočítat průměr každého řádku v matici. Tj. vypočitat aritmetickou střední hodnotu.

  Více informací najdete v encyklopediích Mathworld (text je v angličtině) a Wikipedia (text je v angličtině).

RowMedian

      RowMedian (m)

  Vypočítat medián každého řádku v matici a vrátit sloupcový vektor mediánů.

  Více informací najdete v encyklopediích Mathworld (text je v angličtině) a Wikipedia.

RowPopulationStandardDeviation

      RowPopulationStandardDeviation (m)

  Alternativní názvy: `rowstdevp`

  Spočítat standardní odchylku souboru řádků matice a vrátit svislý vektor.

RowStandardDeviation

      RowStandardDeviation (m)

  Alternativní názvy: `rowstdev`

  Spočítat standardní odchylku řádků matice a vrátit svislý vektor.

StandardDeviation

      StandardDeviation (m)

  Alternativní názvy: `stdev`

  Spočítat standardní odchylku celé matice.

### Polynomy

AddPoly

      AddPoly (p1,p2)

  Sečíst dva polynomy (vektory).

DividePoly

      DividePoly (p,q,&r)

  Podělit dva polynomy (jako vektory) pomocí dlouhého dělení. Vrátit rozdíl dvou polynomů. Volitelný argument `r` se použije k vrácení zbytku. Zbytek bude mít nižší řád, než polynom `q`.

  Více informací najdete v encyklopedii Planetmath (text je v angličtině).

IsPoly

      IsPoly (p)

  Zkontrolovat, zda je vektor použitelný jako polynom.

MultiplyPoly

      MultiplyPoly (p1,p2)

  Vynásobit dva polynomy (jako vektory).

NewtonsMethodPoly

      NewtonsMethodPoly (poly,odhad,epsilon,maxn)

  Najde kořeny polynomu pomocí metody tečen (Newtonovy metody). `poly` je polynom v podobě vektoru a `odhad` je počáteční odhad. Funkce vrací výsledek po dvou úspěšných hodnotách, které každá spadají do `epsilon` nebo po `maxn` pokusech, v kterémžto případě vrací `null`, což značí selhání.

  Viz také `NewtonsMethod`.

  Example to find the square root of 10:

      genius> NewtonsMethodPoly([-10,0,1],3,10^-10,100)

  Více informací najdete v encyklopedii Wikipedia.

Poly2ndDerivative

      Poly2ndDerivative (p)

  Vypočítat druhou derivaci polynomu (jako vektoru).

PolyDerivative

      PolyDerivative (p)

  Derivovat polynom (jako vektor).

PolyToFunction

      PolyToFunction (p)

  Vytvořit funkci z polynomu (jako vektoru).

PolyToString

      PolyToString (p,prom...)

  Vytvořit řetězec z polynomu (jako vektoru).

SubtractPoly

      SubtractPoly (p1,p2)

  Odečíst dva polynomy (jako vektory).

TrimPoly

      TrimPoly (p)

  Odstranit nuly z polynomu (jako vektoru).

### Teorie množin

Intersection

      Intersection (X,Y)

  Vrátit průnik množin X a Y (X a Y jsou vektory považované za množiny).

IsIn

      IsIn (x,X)

  Vrátit `true` (pravda), pokud je x prvkem množiny X (kde X je vektor považovaný za množinu).

IsSubset

      IsSubset (X, Y)

  Vrátit `true` (pravda), pokud X je podmnožinu Y (X a Y jsou vektory považované za množiny).

MakeSet

      MakeSet (X)

  Vrátit vektor, ve kterém se každý prvek X vyskytuje jen jednou.

SetMinus

      SetMinus (X,Y)

  Vrátit rozdíl množin X-Y (X a Y jsou vektory považované za množiny).

Union

      Union (X,Y)

  Vrátit sjednocení množin X a Y (X a Y jsou vektory považované za množiny).

### Komutativní algebra

MacaulayBound

      MacaulayBound (c,d)

  Pro Hilbertovu funkci jde o c pro stupeň d, daný Macaulayho ohraničením pro Hilbertovu funkci stupně d+1 (operátor c^<d> z Greenova důkazu)

  Verze 1.0.15 a novější.

MacaulayLowerOperator

      MacaulayLowerOperator (c,d)

  Operátor c_<d> z Greenova důkazu Macaulayova teorému

  Verze 1.0.15 a novější.

MacaulayRep

      MacaulayRep (c,d)

  Vrátit d-tou Macaulayho reprezentaci celého kladného čísla c.

  Verze 1.0.15 a novější.

### Různé

ASCIIToString

      ASCIIToString (vektor)

  Převést vektor hodnot ASCII na řetězec. Viz také `StringToASCII`.

  Example:

      genius> ASCIIToString([97,98,99])
      = "abc"

  Více informací najdete v encyklopedii Wikipedia.

AlphabetToString

      AlphabetToString (vektor,abeceda)

  Převést vektor na hodnoty indexů písmen indexované od 0 (nacházejících se v textovém řetězci) na řetězec. Vektor `null` vede na prázdný řetězec. Viz také `StringToAlphabet`.

  Examples:

      genius> AlphabetToString([1,2,3,0,0],"abcd")
      = "bcdaa"
      genius> AlphabetToString(null,"abcd")
      = ""

StringToASCII

      StringToASCII (retezec)

  Převést řetězec na (řádkový) vektor hodnot ASCII. Viz také `ASCIIToString`.

  Example:

      genius> StringToASCII("abc")
      = [97, 98, 99]

  Více informací najdete v encyklopedii Wikipedia.

StringToAlphabet

      StringToAlphabet (retezec,abeceda)

  Převést řetězec na (řádkový) vektor na hodnoty indexů písmen indexované od 0 (nacházejících se v textovém řetězci), případně -1 pro neznámá písmena. Prázdný řetězec vede na `null`. Viz také `AlphabetToString`.

  Examples:

      genius> StringToAlphabet("cca","abcd")
      = [2, 2, 0]
      genius> StringToAlphabet("ccag","abcd")
      = [2, 2, 0, -1]

### Symbolické operace

SymbolicDerivative

      SymbolicDerivative (f)

  Zkusit symbolicky derivovat funkci f, kde f je funkce jedné proměnné.

  Examples:

      genius> SymbolicDerivative(sin)
      = (`(x)=cos(x))
      genius> SymbolicDerivative(`(x)=7*x^2)
      = (`(x)=(7*(2*x)))

  Více informací najdete v encyklopedii Wikipedia.

SymbolicDerivativeTry

      SymbolicDerivativeTry (f)

  Zkusit symbolicky derivovat funkci f, kde f je funkce jedné proměnné, při neúspěchu vrátit potichu `null`. (Viz `SymbolicDerivative`)

  Více informací najdete v encyklopedii Wikipedia.

SymbolicNthDerivative

      SymbolicNthDerivative (f,n)

  Zkusit symbolicky n-krát derivovat funkci. (Viz `SymbolicDerivative`)

  Více informací najdete v encyklopedii Wikipedia.

SymbolicNthDerivativeTry

      SymbolicNthDerivativeTry (f,n)

  Zkusit symbolicky n-krát derivovat funkci, při neúspěchu vrátit potichu `null`. (Viz `SymbolicNthDerivative`)

  Více informací najdete v encyklopedii Wikipedia.

SymbolicTaylorApproximationFunction

      SymbolicTaylorApproximationFunction (f,x0,n)

  Zkusit sestavit Taylorův polynom do n-tého řádku se středem x0, který aproximuje zadanou funkci. (Viz `SymbolicDerivative`)

### Vykreslování

ExportPlot

      ExportPlot (soubor,typ)

      ExportPlot (soubor)

  Exportovat obsah okna s grafem do souboru. Typ je řetězec, který určuje typ souboru, který se má použít – „png“, „eps“ nebo „ps“. Když typ souboru není zadán, určí se podle přípony, která by v takovém případě mela být „.png“, „.eps“ nebo „.ps“.

  Upozorňujeme, že soubory se přepisují bez dotazu.

  Při úspěšném exportu je vrácena hodnota pravda. Jinak je vypsána chyba a vyvolána výjimka.

  Examples:

      genius> ExportPlot("file.png")
      genius> ExportPlot("/directory/file","eps")

  Verze 1.0.16 a novější.

LinePlot

      LinePlot (fce1,fce2,fce3,...)

      LinePlot (fce1,fce2,fce3,x1,x2)

      LinePlot (fce1,fce2,fce3,x1,x2,y1,y2)

      LinePlot (fce1,fce2,fce3,[x1,x2])

      LinePlot (fce1,fce2,fce3,[x1,x2,y1,y2])

  Vykreslí funkci (nebo několik funkcí) v podobě čárového grafu. Prvních (až 10) argumentů jsou funkce, volitelně můžete zadat meze vykreslovaného okna jako souřadnice `x1`, `x2`, `y1`, `y2`. Pokud žádné meze nejsou zadány, použijí se aktuálně nastavené meze (viz `LinePlotWindow`). Pokud nejsou zadány jen meze v ose y, funkce se propočítají a vezme se jejich minimum a maximu.

  Parametr `LinePlotDrawLegends` ovládá vykreslování legendy.

  Examples:

      genius> LinePlot(sin,cos)
      genius> LinePlot(`(x)=x^2,-1,1,0,1)

LinePlotClear

      LinePlotClear ()

  Zobrazí okno pro vykreslování čar a vymaže funkce a ostatní čáry, které jsou v něm vykresleny.

LinePlotCParametric

      LinePlotCParametric (fce,...)

      LinePlotCParametric (fce,t1,t2,tprirust)

      LinePlotCParametric (fce,t1,t2,tprirust,x1,x2,y1,y2)

  Vykreslit parametrickou funkci komplexní hodnoty v podobě čárového grafu. Jako první se předává funkce, která vrací `x+iy`, následovaná volitelnými omezeními `t1,t2,tprirust` pro `t` a pak mezemi v podobě `x1,x2,y1,y2`.

  Pokud žádné meze nejsou zadány, použijí se aktuálně nastavené meze (viz `LinePlotWindow`). Místo mezí x a y je možné zadat řetězec "fit" a meze se pak zvolí podle maximálního rozsahu grafu.

  Parametr `LinePlotDrawLegends` ovládá vykreslování legendy.

LinePlotDrawLine

      LinePlotDrawLine (x1,y1,x2,y2,...)

      LinePlotDrawLine (v,...)

  Vykreslit čáru z `x1`,`y1` do `x2`,`y2`. `x1`,`y1`, `x2`,`y2` může být pro delší lomené čáry nahrazeno maticí `n` krát 2. Připadně vektor `v` může být sloupcový vektor komplexních čísel, což je matice `n` krát 1 a jednotlivá komplexní čísla jsou pak považována za body v rovině.

  Mohou být přidány dodatečné parametry, které určují barvu, tloušťku a šipky čáry a vykreslení okna nebo legendy. Stačí přidat argument v podobě řetězce `"color"`, `"thickness"`, `"window"`, `"arrow"` nebo `"legend"` a za ním určit barvu, tloušťku, okno jako 4prvkový vektor, typ šipky nebo legendu. (Šipka a okno jsou podporovány od verze 1.0.6.)

  Pokud je čára považovaná za vyplněný mnohoúhelník, vyplněný danou barvou, můžete zadat argument `"filled"`. K dispozici od verze 1.0.22.

  Barva by měla být buď řetězec symbolizující běžným anglickým slovem barvu, kterou rozpozná GTK, jako `"red"`, `"blue"`, `"yellow"`, apod. Nebo druhou možností je zadat barvu ve formátu RGB jako `"#rgb"`, `"#rrggbb"` nebo `"#rrrrggggbbbb"`, kde r, g a b jsou číslice šestnáctkové soustavy červené, zelené a modré složky barvy. A nakonec třetí možností, od verze 1.0.18, je také určení barvy vektorem reálných čísel, která představují červenou, zelenou a modrou složku v rozmezí 0 až 1, např. `[1.0,0.5,0.1]`.

  Okno by mělo být zadáno buď obvyklým způsobem jako `[x1,x2,y1,y2]` nebo alternativně může být použit řetězec `"fit"`, v kterémž to případě bude rozsah x určen přesně a rozsah y bude nastaven s pětiprocentním přesahem křivky.

  Specifikace šipky by měla být `"origin"` (počátek), `"end"` (konec), `"both"` (obojí) nebo `"none"` (nic).

  A nakonec legenda, která by měla být zadána jako řetězec, který se použije k osvětlení grafu. Samozřejmě jen v případě, že se legenda tiskne.

  Examples:

      genius> LinePlotDrawLine(0,0,1,1,"color","blue","thickness",3)
      genius> LinePlotDrawLine([0,0;1,-1;-1,-1])
      genius> LinePlotDrawLine([0,0;1,1],"arrow","end")
      genius> LinePlotDrawLine(RungeKuttaFull(`(x,y)=y,0,0.001,10,100),"color","blue","legend","The Solution")
      genius> for r=0.0 to 1.0 by 0.1 do LinePlotDrawLine([0,0;1,r],"color",[r,(1-r),0.5],"window",[0,1,0,1])
      genius> LinePlotDrawLine([0,0;10,0;10,10;0,10],"filled","color","green")

  Na rozdíl od většiny ostatních funkcí, u kterých je jedno, jestli je předán sloupcový nebo řádkový vektor, při zadávání bodů v podobě vektoru komplexních čísel je kvůli možným nejednoznačnostem nutné vždy zadat sloupcový vektor.

  Zadávání `v` jako sloupcového vektoru komplexních čísel je implementováno od verze 1.0.22.

LinePlotDrawPoints

      LinePlotDrawPoints (x,y,...)

      LinePlotDrawPoints (v,...)

  Vykreslit bod v `x`, `y`. Vstupem může být matice `n` krát 2 pro `n` různých bodů. Tato funkce má v podstatě stejné vstupní údaje jako LinePlotDrawLine. Případně vektor `v` může být sloupcový vektor komplexních čísel, což je matice `n` krát 1 a jednotlivá komplexní čísla jsou považována za body v rovině.

  Mohou být přidány dodatečné parametry, které určují barvu a tloušťku čáry a vykreslení okna nebo legendy. Stačí přidat argument v podobě řetězce `"color"`, `"thickness"`, `"window"` nebo `"legend"` a za ním určit barvu, tloušťku, okno jako 4prvkový vektor nebo legendu.

  Barva by měla být buď řetězec symbolizující běžným anglickým slovem barvu, kterou rozpozná GTK, jako `"red"`, `"blue"`, `"yellow"`, apod. Nebo druhou možností je zadat barvu ve formátu RGB jako `"#rgb"`, `"#rrggbb"` nebo `"#rrrrggggbbbb"`, kde r, g a b jsou číslice šestnáctkové soustavy červené, zelené a modré složky barvy. A nakonec třetí možností je také určení barvy vektorem reálných čísel, která představují červenou, zelenou a modrou složku v rozmezí 0 až 1.

  Okno by mělo být zadáno buď obvyklým způsobem jako `[x1,x2,y1,y2]` nebo alternativně může být použit řetězec `"fit"`, v kterémž to případě bude rozsah x určen přesně a rozsah y bude nastaven s pětiprocentním přesahem křivky.

  A nakonec legenda, která by měla být zadána jako řetězec, který se použije k osvětlení grafu. Samozřejmě jen v případě, že se legenda tiskne.

  Examples:

      genius> LinePlotDrawPoints(0,0,"color","blue","thickness",3)
      genius> LinePlotDrawPoints([0,0;1,-1;-1,-1])
      genius> LinePlotDrawPoints(RungeKuttaFull(`(x,y)=y,0,0.001,10,100),"color","blue","legend","The Solution")
      genius> LinePlotDrawPoints([1;1+1i;1i;0],"thickness",5)
      genius> LinePlotDrawPoints(ApplyOverMatrix((0:6)',`(k)=exp(k*2*pi*1i/7)),"thickness",3,"legend","The 7th roots of unity")

  Na rozdíl od většiny ostatních funkcí, u kterých je jedno, jestli jim předáte sloupcový nebo řádkový vektor, může u předávání bodu v podobě vektoru komplexních čísel docházet k nejednoznačnostem. Proto musíte vždy předat sloupcový vektor. Všimněte si v posledním příkladu transpozice vektoru `0:6`, aby se z něj stal sloupcový vektor.

  Dostupné od verze 1.0.18. Zadávání `v` v podobě sloupcového vektoru komplexních čísel je implementováno od verze 1.0.22.

LinePlotMouseLocation

      LinePlotMouseLocation ()

  Vrátit řádkový vektor v kreslení odpovídající aktuální pozici myši. Pokud kreslení není viditelné, vypíše se chyba a vrátí `null`. V takovém případě byste měli spustit `LinePlot` nebo `LinePlotClear`, abyste přepnuli okno s grafem do režimu kreslení. Viz také `LinePlotWaitForClick`.

LinePlotParametric

      LinePlotParametric (xfce,yfce,...)

      LinePlotParametric (xfce,yfce,t1,t2,tprirust)

      LinePlotParametric (xfce,yfce,t1,t2,tprirust,x1,x2,y1,y2)

      LinePlotParametric (xfce,yfce,t1,t2,tprirust,[x1,x2,y1,y2])

      LinePlotParametric (xfce,yfce,t1,t2,tprirust, "fit")

  Vykreslit parametrickou funkci v podobě čárového grafu. Jako první se zadávají funkce pro `x` a `y`, následované volitelnými omezeními `t1,t2,tprirust` pro `t` a pak mezemi v podobě `x1,x2,y1,y2`.

  Pokud žádné meze nejsou zadány, použijí se aktuálně nastavené meze (viz `LinePlotWindow`). Místo mezí x a y je možné zadat řetězec "fit" a meze se pak zvolí podle maximálního rozsahu grafu.

  Parametr `LinePlotDrawLegends` ovládá vykreslování legendy.

LinePlotWaitForClick

      LinePlotWaitForClick ()

  Pokud je v režimu kreslení, čeká na kliknutí v kreslícím okně a následně vrátí pozici kliknutí v podobě řádkového vektoru. Pokud je okno zavřené, vrátí se funkce okamžitě s hodnotou `null`. Pokud okno není v režimu kreslení, přepne jej do něj a, pokud není zobrazené, zobrazí jej. Viz také `LinePlotMouseLocation`.

PlotCanvasFreeze

      PlotCanvasFreeze ()

  Dočasně zmrazí vykreslování grafu na plátno. To se hodí, když kreslíte spoustu prvků a chcete to pozdržet, aby se fyzicky vykreslilo až všechno naráz a předešlo se tím blikání. Až máte veškeré kreslení hotovo, měli byste zavolat funkci `PlotCanvasThaw`.

  Na konci jakéhokoliv provádění je plátno automaticky rozmrazeno, takže by se nemělo stát, že zůstane zmrazené. Kupříkladu ve chvíli, kdy se zobrazí nový příkazový řádek, dojde k automatickému rozmrazení. Také si všimněte, že volání zmrazení a rozmrazení mohou být zanořená.

  Verze 1.0.18 a novější.

PlotCanvasThaw

      PlotCanvasThaw ()

  Rozmrazí plátno pro vykreslování grafu zmrazené pomocí `PlotCanvasFreeze` a ihned jej překreslí. Platno je také rozmrazeno vždy po skončení provádění libovolného programu.

  Verze 1.0.18 a novější.

PlotWindowPresent

      PlotWindowPresent ()

  Zobrazí a přenese do popředí vykreslovací okno, případně jej vytvoří, pokud je třeba. Normálně je okno vytvořeno, když je zavolána některá z kreslících funkcí, ale nemusí být vždy přeneseno do popředí, když je schováno za jinými okny. Proto je dobré volat tento kript, když bylo vykreslovací okno vytvořeno již dříve a nyní je schováno za konzolí nebo jinými okny.

  Verze 1.0.19 a novější.

SlopefieldClearSolutions

      SlopefieldClearSolutions ()

  Vymazat řešení vykreslená funkcí `SlopefieldDrawSolution`.

SlopefieldDrawSolution

      SlopefieldDrawSolution (x, y, dx)

  Když je aktivní vykreslování směrového pole, vykreslí řešení se zadanou počáteční podmínkou. Použita je standardní Rungeho-Kuttova metoda s přírůstkem `dx`. Řešení v grafu zůstanou, dokud není zobrazen jiný graf nebo není zavolána funkce `SlopefieldClearSolutions`. Pro vykreslení řešení můžete použít i grafické rozhraní a počáteční podmínky zadat pomocí myši.

SlopefieldPlot

      SlopefieldPlot (fce)

      SlopefieldPlot (fce,x1,x2,y1,y2)

  Vykreslit směrové pole. Funkce `fce` by měla přebírat dvě reálná čísla `x` a `y` nebo jedno komplexní číslo. Volitelně můžete zadat meze vykreslovacího okna jako souřadnice `x1`, `x2`, `y1`, `y2`. Pokud žádné meze nejsou zadány, použijí se aktuálně nastavení mezí (viz `LinePlotWindow`).

  Parametr `LinePlotDrawLegends` ovládá vykreslování legendy.

  Examples:

      genius> SlopefieldPlot(`(x,y)=sin(x-y),-5,5,-5,5)

SurfacePlot

      SurfacePlot (fce)

      SurfacePlot (fce,x1,x2,y1,y2,z1,z2)

      SurfacePlot (fce,x1,x2,y1,y2)

      SurfacePlot (fce,[x1,x2,y1,y2,z1,z2])

      SurfacePlot (fce,[x1,x2,y1,y2])

  Vykreslit funkci plochy, která přebírá buď dva argumenty nebo komplexní číslo. Jako první se předává funkce, pak následují meze `x1`, `x2`, `y1`, `y2`, `z1`, `z2`. Pokud žádné meze nejsou zadány, použijí se aktuálně nastavené meze (viz `SurfacePlotWindow`). V současnosti umí Genius vykreslovat jen funkci jedné plochy.

  Když nejsou meze zadány, použije se pro ně minimum a maximum funkce.

  Examples:

      genius> SurfacePlot(|sin|,-1,1,-1,1,0,1.5)
      genius> SurfacePlot(`(x,y)=x^2+y,-1,1,-1,1,-2,2)
      genius> SurfacePlot(`(z)=|z|^2,-1,1,-1,1,0,2)

SurfacePlotClear

      SurfacePlotClear ()

  Zobrazí okno pro vykreslování povrchů a vymaže funkce a ostatní čáry, které jsou v něm vykresleny.

  Dostupné ve verzi 1.0.19 a novějších.

SurfacePlotData

      SurfacePlotData (data)

      SurfacePlotData (data,popisek)

      SurfacePlotData (data,x1,x2,y1,y2,z1,z2)

      SurfacePlotData (data,popisek,x1,x2,y1,y2,z1,z2)

      SurfacePlotData (data,[x1,x2,y1,y2,z1,z2])

      SurfacePlotData (data,popisek,[x1,x2,y1,y2,z1,z2])

  Vykreslit povrch podle dat. Data jsou matice n × 3, jejíž řádky jsou souřadnice x, y a z. Případně data mohou být vektor, jehož délka je dělitelná 3 a který obsahuje trojice x, y, z. Data by měla obsahovat nejméně 3 body.

  Volitelně je možné předat popisek a také volitelné meze. Když meze nejsou uvedeny, vypočtou se z dat, ale nepoužívá se funkce `SurfacePlotWindow`, pokud ji chcete použít, musíte to provést explicitně. Když není předán popisek, použije se prázdný.

  Examples:

      genius> SurfacePlotData([0,0,0;1,0,1;0,1,1;1,1,3])
      genius> SurfacePlotData(data,"My data")
      genius> SurfacePlotData(data,-1,1,-1,1,0,10)
      genius> SurfacePlotData(data,SurfacePlotWindow)

  Here's an example of how to plot in polar coordinates, in particular how to plot the function `-r^2 * theta`:

      genius> d:=null; for r=0 to 1 by 0.1 do for theta=0 to 2*pi by pi/5 do d=[d;[r*cos(theta),r*sin(theta),-r^2*theta]];
      genius> SurfacePlotData(d)

  Verze 1.0.16 a novější.

SurfacePlotDataGrid

      SurfacePlotDataGrid (data,[x1,x2,y1,y2])

      SurfacePlotDataGrid (data,[x1,x2,y1,y2,z1,z2])

      SurfacePlotDataGrid (data,[x1,x2,y1,y2],popisek)

      SurfacePlotDataGrid (data,[x1,x2,y1,y2,z1,z2],popisek)

  Vykreslit plochu podle pravidelných obdélníkových dat. Data jsou dána v matici n krát m, kde řádky jsou souřadnice x a sloupce souřadnice y. Souřadnice x je rozdělena do stejnoměrných n-1 intervalů a souřadnice y do stejnoměrných m-1 intervalů. Meze `x1` a `x2` udávájí rozsah na ose x, který se má použit a obdobně meze `y1` a `y2` udávají rozsah na ose y. Pokud nejsou uvedeny meze `z1` a `z2`, jsou vypočteny z dat (budou to extrémní hodnoty v datech).

  Volitelně se může zadat popisek, pokud zadán není, použije se prázdný.

  Examples:

      genius> SurfacePlotDataGrid([1,2;3,4],[0,1,0,1])
      genius> SurfacePlotDataGrid(data,[-1,1,-1,1],"My data")
      genius> d:=null; for i=1 to 20 do for j=1 to 10 do d@(i,j) = (0.1*i-1)^2-(0.1*j)^2;
      genius> SurfacePlotDataGrid(d,[-1,1,0,1],"half a saddle")

  Verze 1.0.16 a novější.

SurfacePlotDrawLine

      SurfacePlotDrawLine (x1,y1,z1,x2,y2,z2,...)

      SurfacePlotDrawLine (v,...)

  Vykreslit čáru z `x1`,`y1`,`z1` do `x2`,`y2`,`z2`. `x1`, `y1`, `z1`, `x2`, `y2`, `z2` může být pro delší lomené čáry nahrazeno maticí `n` krát 3.

  Mohou být přidány dodatečné parametry, které určují barvu a tloušťku čáry a vykreslení okna nebo legendy. Stačí přidat argument v podobě řetězce `"color"`, `"thickness"`, `"window"` nebo `"legend"` a za ním určit barvu, tloušťku, okno jako 6prvkový vektor nebo legendu.

  Barva by měla být buď řetězec symbolizující běžným anglickým slovem barvu, kterou rozpozná GTK, jako `"red"`, `"blue"`, `"yellow"`, apod. Nebo druhou možností je zadat barvu ve formátu RGB jako `"#rgb"`, `"#rrggbb"` nebo `"#rrrrggggbbbb"`, kde r, g a b jsou číslice šestnáctkové soustavy červené, zelené a modré složky barvy. A nakonec třetí možností, od verze 1.0.18, je také určení barvy vektorem reálných čísel, která představují červenou, zelenou a modrou složku v rozmezí 0 až 1, např. `[1.0,0.5,0.1]`.

  Okno by mělo být zadáno buď obvyklým způsobem jako `[x1,x2,y1,y2,z1,z2]` nebo alternativně může být použit řetězec `"fit"`, v kterémž to případě bude rozsah x určen přesně a rozsah y bude nastaven s pětiprocentním přesahem křivky.

  A nakonec legenda, která by měla být zadána jako řetězec, který se použije k osvětlení grafu. Samozřejmě jen v případě, že se legenda tiskne.

  Examples:

      genius> SurfacePlotDrawLine(0,0,0,1,1,1,"color","blue","thickness",3)
      genius> SurfacePlotDrawLine([0,0,0;1,-1,2;-1,-1,-3])

  Dostupné ve verzi 1.0.19 a novějších.

SurfacePlotDrawPoints

      SurfacePlotDrawPoints (x,y,z,...)

      SurfacePlotDrawPoints (v,...)

  Vykreslit bod v `x`,`y`,`z`. Vstupem může být matice `n` krát 3 pro `n` různých bodů. Tato funkce má v podstatě stejné vstupní údaje jako SurfacePlotDrawLine.

  Mohou být přidány dodatečné parametry, které určují barvu a tloušťku čáry a vykreslení okna nebo legendy. Stačí přidat argument v podobě řetězce `"color"`, `"thickness"`, `"window"` nebo `"legend"` a za ním určit barvu, tloušťku, okno jako 6prvkový vektor nebo legendu.

  Barva by měla být buď řetězec symbolizující běžným anglickým slovem barvu, kterou rozpozná GTK, jako `"red"`, `"blue"`, `"yellow"`, apod. Nebo druhou možností je zadat barvu ve formátu RGB jako `"#rgb"`, `"#rrggbb"` nebo `"#rrrrggggbbbb"`, kde r, g a b jsou číslice šestnáctkové soustavy červené, zelené a modré složky barvy. A nakonec třetí možností je také určení barvy vektorem reálných čísel, která představují červenou, zelenou a modrou složku v rozmezí 0 až 1.

  Okno by mělo být zadáno buď obvyklým způsobem jako `[x1,x2,y1,y2,z1,z2]` nebo alternativně může být použit řetězec `"fit"`, v kterémž to případě bude rozsah x určen přesně a rozsah y bude nastaven s pětiprocentním přesahem křivky.

  A nakonec legenda, která by měla být zadána jako řetězec, který se použije k osvětlení grafu. Samozřejmě jen v případě, že se legenda tiskne.

  Examples:

      genius> SurfacePlotDrawPoints(0,0,0,"color","blue","thickness",3)
      genius> SurfacePlotDrawPoints([0,0,0;1,-1,2;-1,-1,1])

  Dostupné ve verzi 1.0.19 a novějších.

VectorfieldClearSolutions

      VectorfieldClearSolutions ()

  Vymazat řešení vykreslené funkcí `VectorfieldDrawSolution`.

  Verze 1.0.6 a novější.

VectorfieldDrawSolution

      VectorfieldDrawSolution (x, y, dt, tdelka)

  Když je aktivní vykreslování vektorového pole, vykreslí řešení se zadanou počáteční podmínkou. Použita je standardní Rungeho-Kuttova metoda s přírůstkem `dt` pro interval délky `tdelka`. Řešení v grafu zůstanou, dokud není zobrazen jiný graf nebo není zavolána funkce `VectorfieldClearSolutions`. Pro vykreslení řešení můžete použít i grafické rozhraní a počáteční podmínky zadat pomocí myši.

  Verze 1.0.6 a novější.

VectorfieldPlot

      VectorfieldPlot (fcex, fcey)

      VectorfieldPlot (fcex, fcey, x1, x2, y1, y2)

  Vykreslit dvourozměrné vektorové pole. Funkce `fcex` by měla být dx/dt vektorového pole a funkce `fcey` by měla být dy/dt vektorového pole. Funkce by měly přebírat dvě reálná čísla `x` a `y` nebo jedno komplexní číslo. Pokud je parametr `VectorfieldNormalized` nastaven na `true`, pak je velikost vektorů normalizována. To znamená, že je zobrazen jen směr a velikost ne.

  Volitelně můžete zadat meze vykreslovaného okna jako souřadnice `x1`, `x2`, `y1`, `y2`. Pokud žádné meze nejsou zadány, použijí se aktuálně nastavené meze (viz `LinePlotWindow`).

  Parametr `LinePlotDrawLegends` ovládá vykreslování legendy.

  Examples:

      genius> VectorfieldPlot(`(x,y)=x^2-y, `(x,y)=y^2-x, -1, 1, -1, 1)

## Příklad programů v jazyce GEL

Here is a function that calculates factorials:

    function f(x) = if x <= 1 then 1 else (f(x-1)*x)

With indentation it becomes:

    function f(x) = (
      if x <= 1 then
        1
      else
        (f(x-1)*x)
    )

This is a direct port of the factorial function from the bc manpage. The syntax seems similar to bc, but different in that in GEL, the last expression is the one that is returned. Using the `return` function instead, it would be:

    function f(x) = (
      if (x <= 1) then return (1);
      return (f(x-1) * x)
    )

By far the easiest way to define a factorial function would be using the product loop as follows. This is not only the shortest and fastest, but also probably the most readable version.

    function f(x) = prod k=1 to x do k

Here is a larger example, this basically redefines the internal `ref` function to calculate the row echelon form of a matrix. The function `ref` is built in and much faster, but this example demonstrates some of the more complex features of GEL.

    # Calculate the row-echelon form of a matrix
    function MyOwnREF(m) = (
      if not IsMatrix(m) or not IsValueOnly(m) then
        (error("MyOwnREF: argument not a value only matrix");bailout);
      s := min(rows(m), columns(m));
      i := 1;
      d := 1;
      while d <= s and i <= columns(m) do (

        # This just makes the anchor element non-zero if at
        # all possible
        if m@(d,i) == 0 then (
          j := d+1;
          while j <= rows(m) do (
            if m@(j,i) == 0 then
              (j=j+1;continue);
            a := m@(j,);
            m@(j,) := m@(d,);
            m@(d,) := a;
            j := j+1;
            break
          )
        );
        if m@(d,i) == 0 then
          (i:=i+1;continue);

        # Here comes the actual zeroing of all but the anchor
        # element rows
        j := d+1;
        while j <= rows(m)) do (
          if m@(j,i) != 0 then (
            m@(j,) := m@(j,)-(m@(j,i)/m@(d,i))*m@(d,)
          );
          j := j+1
        );
        m@(d,) := m@(d,) * (1/m@(d,i));
        d := d+1;
        i := i+1
      );
      m
    )

## Nastavení

To configure Genius Mathematics Tool, choose Settings Preferences. There are several basic parameters provided by the calculator in addition to the ones provided by the standard library. These control how the calculator behaves.

Změna nastavení pomocí GEL

Většina nastavení v aplikaci Genius jsou ve skutečnosti globální proměnné, u kterých můžete zjistit hodnotu a hodnotu jim přiřadit, stejně jako u normálních proměnných. Viz o vyhodnocování a přiřazování proměnných a pro seznam nastavení, která lze tímto způsobem měnit.

As an example, you can set the maximum number of digits in a result to 12 by typing:

    MaxDigits = 12

### Výstup

Maximum digits to output

  Maximum číslic ve výsledcích (`MaxDigits`)

Results as floats

  Zda by se výsledky měly vždy vypisovat v podobě desetinných čísel (`ResultsAsFloats`)

Floats in scientific notation

  Zda by desetinná čísla měla být ve vědecké notaci (`ScientificNotation`)

Always print full expressions

  Zda by se měly vypisovat úplné výrazy pro vrácené nečíselné hodnoty (delší než řádek) (`FullExpressions`)

Use mixed fractions

  Zda by zlomky měly být vypisovány jako smíšené, například „1 1/3“ místo „4/3“. (`MixedFractions`)

Display 0.0 when floating point number is less than 10^-x (0=never chop)

  Jak osekávat výstup. Ale jen když jsou ostatní sousedící čísla velká. Podívejte se na dokumentaci k parametru `OutputChopExponent`.

Only chop numbers when another number is greater than 10^-x

  Kdy osekávat výstup. Nastavení je dáno parametrem `OutputChopWhenExponent`. Viz dokumentace k parametru `OutputChopExponent`.

Remember output settings across sessions

  Zda by se měla nastavení zadaná ve skupině Volby výstup čísel/výrazů zapamatovat pro příští sezení. Neplatí pro nastavení ve skupině Volby výstupu chyb/informací.

  Když není zaškrtnuto, požívají se při každém spuštění kalkulátoru Genisu výchozí nebo dříve uložená nastavení. Uvědomte si, že nastavení jsou ukládána na konci sezení, takže pokud si chcete uložit výchozí nastavení postupujte následovně: zaškrtněte políčko, matematický nástroj Genius restartujte a u políčka zaškrtnutí zase zrušte.

Display errors in a dialog

  Když je nataveno, budou chyby zobrazovány v samostatném dialogovém okně, když není nastaveno, budou vypisovány v konzole.

Display information messages in a dialog

  Když je nastaveno, budou informativní zprávy zobrazovány v samostatném dialogovém okně, když není nataveno, budou vypisovány v konzole.

Maximum errors to display

  Maximální počet chyb, který je vrácen během jednoho vyhodnocení (`MaxErrors`). Pokud nastavíte na 0, budou vždy vráceny všechny chyby. Obvykle když smyčka způsobí hodně chyb, je nepravděpodobné, že jich bude mít význam více než pár, takže prohlížení dlouhého seznam nemá žádný přínos.

Mimo tyto předvolby existují ještě další předvolby, které mohou být změněny pouze přes prostředí konzoly. Tyto další volby, které se týkají výstupu najdete v kapitole .

`IntegerOutputBase`

  Číselná soustava, která se bude používat pro vypisování celých čísel

`OutputStyle`

  Řetězec, který může nabývat hodnot `„normal“`, `„latex“`, `„mathml“` nebo `„troff“` a bude ovlivňovat, jak se mají vypisovat matice (a samozřejmě i další věci), což je důležité pro vkládání do dokumentů. Styl Normal je výchozí styl výpisu matematického nástroje Genius čitelný pro člověka. Ostatní styly jsou pro sazbu v aplikacích LaTeX, MathML (XML) nebo Troff.

### Přesnost

Floating point precision

  Přesnost desetinných čísel v bitech (`FloatPrecision`). Vemte na vědomí, že změny se použijí až na nově vypočtené hodnoty. Staré hodnoty uložené v proměnných zůstanou samozřejmě v původní přesnosti a pokud je budete chtít s nově nastavenou přesností, musíte je přepočítat. Výjimkou jsou systémové konstanty, jako `pi` nebo `e`.

Remember precision setting across sessions

  Zda by se přesnost měla zapamatovat pro příští sezení. Když není zaškrtnuto, požívají se při každém spuštění kalkulátoru Genisu výchozí nebo dříve uložená nastavení. Uvědomte si, že nastavení jsou ukládána na konci sezení, takže pokud si chcete uložit výchozí nastavení postupujte následovně: zaškrtněte políčko, Genius restartujte a u políčka zaškrtnutí zase zrušte.

### Terminál

Terminál představuje konzolu v pracovní oblasti.

Scrollback lines

  Počet řádků, o které se dá v terminálu vracet zpět.

Font

  Písmo, které se má používat v terminálu.

Black on white

  Zda se má terminálu používat černá na bílé.

Blinking cursor

  Zda by měl kurzor v terminálu blikat, když je terminál zaměřen. To může být někdy nepříjemné a vytvářet provoz při nečinnosti v případě, že používáte aplikaci Genius vzdáleně.

### Paměť

Maximum number of nodes to allocate

  Interně se data ukládají do malých úseků paměti. Tato hodnota udává maximální počet úseků, které se mohou pro výpočty přidělit. Tímto omezením se předejde problémům s vyčerpáním paměti při chybách, které paměti spotřebují velké množství, například při nekonečné rekurzi. Při vyčerpání paměti by došlo ke zpomalení počítače a bylo by obtížné program přerušit.

  Pokud je limit dosažen, matematický nástroj Genius se dotáže, zda si výpočet přejete přerušit nebo se má pokračovat. Jestliže budete pokračovat, žádný limit nebude uplatněn a může nastat, že program paměť vyčerpá. Limit se použije znovu při dalším spuštění programu nebo vyhodnocení výrazu v konzole bez ohledu na to, co jste na dotaz odpověděli.

  Nastavení limitu na nulu znamená, že na množství paměti použité kalkulátorem Genius nebude žádný limit uplatňován.

## O Matematickém nástroji Genius

Genius Mathematics Tool was written by Jiří (George) Lebl (jiri.lebl@gmail.com). The history of Genius Mathematics Tool goes back to late 1997. It was the first calculator program for GNOME, but it then grew beyond being just a desktop calculator. To find more information about Genius Mathematics Tool, please visit the Genius Web page.

Pokud chcete oznámit chybu nebo navrhnout vylepšení vztahující se k této aplikaci nebo této příručce, pošlete e-mail autorovi nebo do poštovní konference (viz webové stránky).

Tento program je šířen podle ustanovení licence GNU General Public License, vydávané Free Software Foundation; a to buď verze 3 této licence anebo (podle vlastního uvážení) kterékoliv pozdější verze. Kopii této licence naleznete pod tímto odkazem nebo v souboru COPYING přiloženém ke zdrojovým kódům tohoto programu.

Jiří Lebl byl během různých částí vývoje částečně podporován v práci od NSF granty DMS 0900885 a DMS 1362337 a univerzitou Illinois v Urbana-Champaign, univerzitou California v San Diegu, univerzitou Wisconsin-Madison a státní univerzitou Oklahoma. Software byl využíván jak k výuce, tak k výzkumu.