# Manual de Genius

## Introducción

La Herramienta matemática Genius es una calculadora de uso general para usarse como una calculadora de escritorio, una herramienta educativa para matemáticas, incluso es útil en investigaciones. El lenguaje utilizado por la Herramienta matemática Genius está diseñado para ser «matemático» en el sentido en que debería ser «lo que quieres decir es lo que obtienes». Por supuesto que no es una meta completamente alcanzable. La Herramienta matemática Genius soporta números racionales, enteros de precisión arbitraria y flotantes de precisión múltiple usando la librería GMP. Maneja números complejos usando notación cartesiana. Tiene buena manipulación de vectores y matrices, y puede manejar álgebra lineal básica. El lenguaje de programación permite funciones definidas por el usuario, variables y modificaciones de los parámetros.

Hay dos versiones de la Herramienta matemática Genius. Una es la versión gráfica para GNOME, que tiene una interfaz de tipo IDE y permite dibujar funciones de una y dos variables. La versión de línea de comandos no necesita GNOME, pero por supuesto no implementa ninguna característica que necesite la interfaz gráfica.

Este manual describe principalmente la versión gráfica de la calculadora pero, por supuesto, el lenguaje es el mismo. La línea de comandos carece de las capacidades de dibujo y de otras capacidades que necesitan la interfaz gráfica de usuario.

## Primeros pasos

### Para iniciar la herramienta matemática Genius

Puede iniciar la herramienta matemática Genius de las siguientes formas:

MenúAplicaciones

- Dependiendo de su sistema operativo y de su versión, el elemento de menú de la Herramienta matemática Genius puede aparecer en varios lugares diferentes. Puede estar en Educación, Accesorios, Oficina, Ciencia, o en un submenú similar, dependiendo de su configuración particular. El elemento de menú que está buscando es Herramienta matemática Genius. Cuando lo haya localizado, pulse en el para iniciar la Herramienta matemática Genius.

Diálogo Ejecutar

- Dependiendo de la instalación de su sistema, el elemento del menú puede no estar disponible. si no lo está, puede abrir el diálogo «Ejecutar» y ejecutar `gnome-genius`.

Linea de comandos

- Para iniciar la versión de GNOME de laherramienta matemática Genius ejecute `gnome-genius` desde la línea de comandos.

  Para iniciar sólo la versión de línea de comandos, ejecute el siguiente comando: `genius`. Esta versión no incluye el entorno gráfico y ciertas funcionalidades, como dibujar, no estarán disponibles.

### Al iniciar Genius

Cuando inicia la versión de la herramienta matemática Genius para GNOME, se muestra la ventana que aparece en la mainwindow-fig.

#### Ventana de la herramienta matemática Genius

Muestra la ventana principal Herramienta matemática Genius. Contiene barra de título, barra de menús, barra de herramientas y área de trabajo. La barra de menú contiene los menús Archivo, Editar, Calculadora, Configuración, y Ayuda.

La ventana de la herramienta matemática Genius contiene los siguientes elementos:

Barra de menú.

- Los menús de la barra de menús contienen todos los comandos que necesita para trabajar con archivos en la Herramienta matemática Genius. El menú Archivo contiene elementos para cargar y guardar elementos y crear programas nuevos. El comando Cargar y ejecutar... no abre una ventana nueva para el programa, sino que lo ejecuta directamente. Es equivalente al comando `load`.

  El menú Calculadora controla el motor de la calculadora. Permite ejecutar el programa actualmente seleccionado o interrumpir el cálculo actual. También puede mirar la expresión completa del último resultado (útil si el último resultado fue demasiado grande para ajustar a la consola), y puede mirar una lista con los valores de todas las variables definidas por el usuario. Finalmente, permite trazar funciones usando un cuadro de diálogo amigable.

  Los otros menús tienen funciones similares a las de otras aplicaciones.

Barra de herramientas.

- La barra de herramientas contiene un subconjunto de comandos a los que puede acceder desde la barra de menús.

Área de trabajo

- El área de trabajo es el método primario para interactuar con la aplicación.

  Inicialmente, el área de trabajo sólo tenía la pestaña Consola, que es el principal medio de interacción con la calculadora. Aquí puede escribir expresiones y el resultado se devuelve inmediatamente después de pulsar la tecla «Intro».

  Alternativamente, puede escribir programas más largos y éstos pueden aparecer en pestañas separadas y se pueden guardar en archivos para su posterior recuperación.

## Uso básico

### Usar el área de trabajo

Normalmente, interactúa con la calculadora en la pestaña Consola. Si ejecuta la versión de solo texto, entonces la consola será el único medio disponible. Si quiere usar la Herramienta matemática Genius como una calculadora solamente, simplemente escriba aquí su expresión y se evaluará.

Escriba su expresión en el área de trabajo de la Consola, pulse «Intro» y la expresión se evaluará. Las expresiones están escritas en un lenguaje llamado GEL. Las expresiones GEL más simples parecen matemáticas. Por ejemplo

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

o

    genius> 62734 + 812634 + 77^4 mod 5

o

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

o

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

(El último es la suma armónica de 1 a 70)

Para obtener una lista de todas las funciones y los comandos, escriba:

    genius> help

Si quiere obtener más información sobre una función en concreto, escriba:

    genius> help nombre_de_la_función

Para ver este manual, escriba:

    genius> manual

Suponga que ha guardado algún comando GEL previamente como un programa en un archivo y quiere ejecutarlo. Para cargar este programa desde el archivo `ruta/a/programa.gel`, escriba

    genius> load ruta/a/programa.gel

laHerramienta matemática Genius mantiene la ruta de la carpeta actual. Para listar los archivos de la carpeta actual, escriba `ls`, para cambiar de carpeta escriba `cd carpeta`, igual que en la línea de comandos de UNIX.

### Crear un programa nuevo

Para escribir un programa nuevo, eliga Archivo Programa Nuevo. Aparecerá una pestaña nueva en el área de trabajo. Puede escribir un programa GEL en esta área de trabajo. Una vez que haya escrito su programa, puede ejecutarlo desde Calculadora Ejecutar. Esto ejecutará su programa y mostrará cualquier salida en la pestaña Consola. Ejecutar un programa es equivalente a tomar el texto del programa y escribirlo en la consola. La única diferencia es que esta entrada se realiza independientemente de la consola y solo la salida va hacia la consola. Calculadora Ejecutar siempre ejecutará el programa actualmente seleccionado incluso si se encuentra en la pestaña Consola. El programa actual tiene su letra en negrita. Para seleccionar un programa, simplemente pulse sobre su pestaña.

Para guardar el programa que ha escrito, elija Archivo Guardar como...

### Abrir y ejecutar un programa

Para abrir un archivo, elija Archivo Abrir. En el área de trabajo aparecerá una pestaña nueva que contiene al archivo. Puede usarla para editarlo.

Para ejecutar un programa desde un archivo, elija Archivo Cargar y ejecutar.... Esto ejecutará el programa sin abrir en una pestaña separada. Es equivalente al comando `load`.

## Dibujar

El soporte de dibujo solo está disponible para la versión gráfica de GNOME. Todo el dibujo disponible desde la interfaz gráfica está disponible en la ventana Crear dibujo. Puede acceder a esta ventana pulsando en el botón Dibujo de la barra de herramientas o seleccionando Dibujo desde el menú Calculadora. También puede acceder a las funcionalidades de dibujo usando las funciones de trazado del lenguaje GEL. Consulte la genius-gel para aprender a introducir expresiones que entienda Genius.

### Trazado de líneas

Para crear gráficas de funciones de valores reales de una variable, abra la ventana Crear dibujo. También puede usar la función `LinePlot` en la línea de comandos (consulte su documentación).

Una vez que pulse el botón Dibujo, se abre una ventana con algunas pestañas en ella. Se encontrará con la pestaña Dibujo de la línea de función y dentro de ella encontrará la pestaña Funciones / Expresiones. Consulte la lineplot-fig.

#### Crear una ventana de dibujo

Muestra la ventana de trazado de líneas

En los cuadros de texto escriba sólo las expresiones donde `x` es la variable independiente. También puede dar simplemente nombres de funciones como `cos` en lugar de tener que escribir `cos(x)`. Puede crear gráficas de hasta 10 funciones. Si comete un error y Genius no puede analizar la entrada, se señalará con un ícono de advertencia a la derecha del cuadro de texto donde ocurrió el error, así como se mostrará un diálogo de error. Puede cambiar los rangos de las variables dependientes e independientes en la parte inferior de la ventana de diálogo. Pulsando el botón Dibujar se producirá el gráfico mostrado en la lineplot2-fig.

#### Ventana de dibujo

El gráfico producido.

Desde aquí puede imprimir el dibujo, crear un PostScript encapsulado o un PNG del dibujo, o cambiar la escala. Si el eje dependiente no se ha establecido correctamente, puede hacer que Genius lo ajuste buscando los extremos de las funciones representadas.

Para dibujar usando la línea de comandos, consulte la documentación de la función `LinePlot`.

### Gráficos paramétricos

En la ventana de crear dibujo, también puede elegir la pestaña Paramétrico para crear dibujos paramétricos bidimensionales. De este modo, puede dibujar una única función paramétrica. Puede especificar los puntos como X e Y, o dar un número complejo único. Consulte la paramplot-fig.

#### Pestaña dibujo paramétrico

Pestaña dibujo paramétrico en la ventana Crear dibujo.

Puede ver un ejemplo de un dibujo paramétrico en la paramplot-fig. Puede realizar operaciones similares en este gráfico, así como en el otro dibujo de líneas. Para dibujar usando la línea de comandos, consulte la documentación de las funciones `LinePlotParametric` o `LinePlotCParametric`.

#### Gráfico paramétrico

Gráfico paramétrico producido

### Dibujos de campos de inclinación

En la ventana de crear dibujo, también puede elegir la pestaña Campo de inclinación para crear dibujos de campos de inclinación bidimensionales. Para dibujar usando la línea de comandos, conuslte la documentación de la función `SlopefieldPlot`.

Cuando un campo de inclinación está activo, hay un menú adicional disponible Solucionador, a través del cual puede abrir el cuadro de diálogo del mismo nombre. Aquí puede tener soluciones específicas de dibujo de Genius. Puede especificar condiciones iniciales en el diálogo, o puede pulsar directamente en el dibujo para indicar el punto inicial. Mientras el diálogo del solucionador esté activo, la ampliación al pulsar y arrastrar no funcionará. Si quiere ampliar usando el cursor tendrá que cerrar el diálogo primero.

El solucionador usa el método Runge-Kutta estándar. Los gráficos se quedarán en la pantalla hasta que los borre. El solucionador se detendrá cuando alcance el límite de la ventana de dibujo. La ampliación no cambia los límites o los parámetros de la solución, tendrá que borrar y redibujar con los parámetros apropiados. También puede usar la función `SlopefieldDrawSolution` para dibujar soluciones desde la línea de comandos o programas.

### Gráficos de campos de vectores

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

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

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

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

### Gráficos de superficie

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

#### Gráfico de superficie

Valor absoluto de la función coseno complejo.

## Conceptos de GEL

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

### Valores

Los valores en GEL pueden ser números, booleanos o cadenas. Los valores se pueden usar en cálculos, asignarse a variables y devolverse desde funciones, entre otros usos.

#### Números

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 if 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`.

El último tipo de números en GEL son los números complejos. Puede escribir un número complejo como la suma de su parte real y su parte imaginaria. La parte imaginaria termina con una `i`. Aquí hay algunos ejemplo de cómo escribir números complejos:

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

Al introducir números imaginarios, deba haber un número delante de la `i`. Si usa `i` por sí sola, Genius lo interpretará como una referencia a la variable `i`. Si necesita referirse a `i` por sí sola, use `1i` en su lugar.

Para usar notación de fracciones mixtas con números imaginarios debe colocar las fracciones mixtas entre paréntesis (ej. `(1 2/5)i`).

#### Booleanos

Genius también soporta valores booleanos nativos. Las dos constantes booleanas están definidas como `true` y `false`; estos identificadores se pueden utilizar como cualquier otra variable. Así mismo, puede utilizar los identificadores `True`, `TRUE`, `False` y `FALSE` como alias de las anteriores.

Puede usar un valor booleano o cualquier expresión que produzca un número o valor booleano en cualquier lugar donde se espera una expresión Booleana. Si Genius necesita evaluar un valor numérico como un valor booleano interpretará «0» como `false` y cualquier otro valor como `true`.

Además, puede efectuar operaciones con valores booleanos. Por ejemplo:

    ( (1 + true) - false ) * true

equivale a:

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

Solamente están soportadas la adición, la sustracción y la multiplicación. Si mezcla valores numéricos con booleanos en una expresión, los valores numéricos se convertirán a booleanos como se describió anteriormente. Esto significa que, por ejemplo:

    1 == true

siempre se evaluará como `true` dado que «1» siempre se convertirá a `true` antes de compararlo con `true`.

#### Cadenas

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;«El resultado es: »+a

will create the string:

    El resultado es: 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:

    "Barra: \\ Comillas: \" Tabulaciones: \t1\t2\t3"

will make a string:

    Barra: \ Comillas: " Tabulaciones: 	1	2	3

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

#### Nulo

Existe un valor especial llamado `null`. No se permite efectuar operaciones sobre él y no se muestra nada cuando se devuelve este valor. Por lo tanto, `null` es útil cuando no quiera ninguna salida de una expresión. El valor `null` puede obtenerse como una expresión al escribir `.`, la constante `null` o nada. Nada referido a que si termina una expresión con un separador `;`, equivale a terminar la expresión con un separador seguido de `null`.

Ejemplo:

    x=5;.
    x=5;

Algunas funciones devuelven `null` cuando no pueden devolver un valor o producen algún error. También se usa `null` como un vector o matriz vacía o una referencia vacía.

### Usar variables

Sintaxis:

    NombreVariable

Ejemplo:

    genius> e
    = 2.71828182846

Para evaluar una variable por sí misma, simplemente introduzca el nombre de la variable. Esto devolverá el valor de la variable. Puede usar una variable en cualquier lugar donde pueda utilizar un número o cadena. Además, las variables son necesarias al definir funciones que toman argumentos (consulte la genius-gel-functions-defining).

#### Usar completado con el tabulador

Puede usar el completado con el tabulador para que Genius complete nombres de las variables. Intente escribir las primeras letras del nombre de la variable y pulse `Tab`.

#### Los nombres de variables son sensibles a la capitalización

Los nombres de variables son sensibles a la capitalización. Esto significa que las variables `hello`, `HELLO` y `Hello` son todas diferentes.

#### Configurar variables

Sintaxis:

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

Ejemplo:

    x = 3
    x := 3

Para asignar una variable, use los operadores `=` o `:=`. Estos operadores establecen el valor de la variable y devuelven el número asignado, así puede hacer cosas como

    a = b = 5

Los operadores `=` y `:=` se pueden usar para asignar variables. La diferencia entre ellos es que `:=` siempre actuará como operador de asignación mientras que `=` se puede interpretar como prueba de igualdad usado en un contexto donde se espera una variable booleana.

Para temas relacionados con el ámbito de las variables, consulte la genius-gel-variables-global.

#### Variables integradas

GEL has a number of built-in ‘variables’, such as `e`, `pi` or `GoldenRatio`. These are widely used constants with a preset value, and they cannot be assigned new values. There are a number of other built-in variables. See genius-gel-function-list-constants for a full list.

#### Resultado de la variable anterior

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

### Usar funciones

Syntax:

    NombreFuncion(argumento1, argumento2, ...)

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.

Hay muchas funciones integradas, como `sin`, `cos` y `tan`. Puede usar la función integrada `help` para obtener una lista de todas las funciones integradas, o ver la genius-gel-function-list para obtener una lista completa..

#### Usar completado con el tabulador

Puede usar completado con el tabulador para que Genius complete nombres de funciones. Pruebe a escribir las primeras letras del nombre y pulse `Tab`.

#### Los nombres de las funciones son sensibles a mayúsculas.

Los nombres de las funciones son sensibles a la capitalización. Esto significa que las funciones `haceralgo`, `HACERALGO` y `HacerAlgo` son todas diferentes entre sí.

#### Definir funciones

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 which Genius can load in order to make available. Example:

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

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

#### Listas de argumentos de variables

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`.

#### Pasar funciones a funciones

En Genius es posible pasar una función como argumento de otra función. Esto se puede hacer usando «nodos de funciones» o funciones anónimas.

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 which are not defined, you can use an anonymous function (see genius-gel-functions-defining). 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.

#### Operaciones con funciones

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

    exp(sin*cos+4)

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

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

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

    f = exp(sin*cos+4)

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

    LinePlot(sin^2)

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

### Valor absoluto / módulo

Puede calcular el valor absoluto de algo encerrándolo entre `|`. Por ejemplo:

    |a-b|

En el caso de que la expresión sea un número complejo el resultado será su módulo (distancia desde el origen). Por ejemplo: `|3 * e^(1i*pi)|` devuelve 3.

### Separador

In GEL if you want to type more than one command you have to use the `;` operator, which is a way to separate expressions, such a combined expression will return whatever is the result of the last one, so 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 somewhat, if a `;` is found at the end of a parenthesis or a block, genius will itself append a null node to it as if you would have written `;null`. This is useful in case you do not want to return a value from say a loop, or if you handle the return differently. Note that it will slightly slow down the code if it is executed too often as there is one more operator involved.

### Evaluación modular

Genius implements modular arithmetic. To use it you just add "mod <integer>" after the expression. Example:

    2^(5!) * 3^(6!) mod 5

It could be possible to do modular arithmetic by computing with integers and then modding in the end with the `%` operator, but that may be time consuming if not impossible when working with larger numbers. For example `10^(10^10) % 6` will simply not work (the exponent will be too large), while `10^(10^10) mod 6` is instanteneous.

You can calculate the inverses of numbers mod some integer by just using rational numbers (of course the inverse has to exist). Examples:

    10^-1 mod 101
    1/10 mod 101

You can also do modular evaluation 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.

### Lista de operadores GEL

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

    a;b

- El separador evalúa `a` y `b`, pero sólo devuelve el valor de `b`.

    a=b

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

    a:=b

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

    |a|

- Valor absoluto o módulo (si `a` es un número complejo).

  Consulte Mathworld para obtener más información.

    a^b

- Exponenciación, eleva `a` a la `b`-ésima potencia.

    a.^b

- Element by element exponentiation. Raise each element of a matrix `a` to the `b`th power. Or if `b` is a matrix of the same size as `a`, then do the operation element by element. If `a` is a number and `b` is a matrix then it creates matrix of the same size as `b` with `a` raised to all the different powers in `b`.

    a+b

- Adición. Suma dos números, matrices, funciones o cadenas. Si suma una cadena a cualquier valor el resultado es una cadena.

    a-b

- Sustracción. Resta dos números, matrices o funciones.

    a*b

- Multiplicación. Es la multiplicación normal de matrices.

    a.*b

- Multiplicación elemento a elemento si `a` y `b` son matrices.

    a/b

- División.

    a./b

- División elemento por elemento.

    a\b

- División hacia atrás. Es lo mismo que `b/a`.

    a.\b

- División hacia atrás elemento por elemento.

    a%b

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

    a.%b

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

    a mod b

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

    a!

- Operador factorial. Esto es `1*...*(n-2)*(n-1)*n`.

    a!!

- Operador doble factorial. Esto es `1*...*(n-4)*(n-2)*n`.

    a==b

- Operador de igualdad (devuelve `true` o `false`).

    a!=b

- Operador de desigualdad, devuelve `true` si `a` no es igual a `b`; si lo es, devuelve `false`.

    a<>b

- Alternative inequality operator, returns `true` if `a` does not equal `b` else returns `false`.

    a<=b

- Operador menor o igual, devuelve `true` si `a` es menor o igual que `b`, si no, devuelve `false`.

    a>=b

- Operador mayor o igual, devuelve `true` si `a` es mayor o igual que `b`, si no, devuelve `false`.

    a<=>b

- Operador de comparación. Si `a` es igual a `b` devuelve 0, si `a` es menor que `b` devuelve -1 y si `a` es mayor que `b` devuelve 1.

    a and b

- AND lógico.

    a or b

- OR lógico.

    a xor b

- XOR lógico.

    not a

- NOT lógico.

    -a

- Operador de negación.

    &a

- Referencia a variable (para pasar la referencia a algo). Consulte la genius-gel-references.

    *a

- Desreferencia a variable (para acceder a una variable referenciada). Consulte la genius-gel-references.

    a'

- Matriz conjugada traspuesta.

    a.'

- Matriz traspuesta, no conjuga los elementos.

    a@(b,c)

- Devuelve el elemento en la fila `b` y columna `c`. Si `b`, `c` son vectores, devuelve las correspondientes filas, columnas o submatrices.

    a@(b,)

- Devuelve la fila de la matriz (o filas si `b` es un vector).

    a@(b,:)

- Igual que el anterior

    a@(,c)

- Devuelve la columna de la matriz (o columnas si `c` es un vector).

    a@(:,c)

- Igual que el anterior

    a@(b)

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

    a:b

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

      A@(2:4,)

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

    a:b:c

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

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

    (a)i

- Make a imaginary number (multiply `a` by the imaginary). Note that normally the number `i` is written as `1i`. So the above is equal to

      (a)*1i

    `a

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

    a swapwith b

- Swap value of `a` with the value of `b`. Currently does not operate on ranges of matrix elements. It returns `null`. Available from version 1.0.13.

    increment a

- Increment the variable `a` by 1. If `a` is a matrix, then increment each element. This is equivalent to `a=a+1`, but it is somewhat faster. It returns `null`. Available from version 1.0.13.

    increment a by b

- Increment the variable `a` by `b`. If `a` is a matrix, then increment each element. This is equivalent to `a=a+b`, but it is somewhat faster. It returns `null`. Available from version 1.0.13.

The @() operator makes the : operator most useful. With this you can specify regions of a matrix. So that a@(2:4,6) is the rows 2,3,4 of the column 6. Or a@(,1:2) will get you the first two columns of a matrix. You can also assign to the @() operator, as long as the right value is a matrix that matches the region in size, or if it is any other type of value.

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

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

## Programar con GEL

### Condicionales

Syntax:

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

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

Ejemplos:

    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 )

Tenga en cuenta que `=` se traducirá como `==` si se usa dentro de una expresión `if`, por lo que

    if a=5 then a=a-1

se interpretará como:

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

### Bucles

#### Bucles «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.

#### Bucles «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)

#### Bucles «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].

#### Parar y continuar

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>
    )

### Sumas y productos

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.

If no body is executed (for example `sum i=1 to 0 do ...`) then `sum` returns 0 and `prod` returns 1 as is the standard convention.

### Operadores de comparación

The following standard comparison operators are supported in GEL and have the obvious meaning: `==`, `>=`, `<=`, `!=`, `<>`, `<`, `>`. They return `true` or `false`. The operators `!=` and `<>` are the same thing and mean "is not equal to". GEL also supports the operator `<=>`, which returns -1 if left side is smaller, 0 if both sides are equal, 1 if left side is larger.

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

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

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

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

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

### Variables globales y ámbito de variables

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

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

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

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

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

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

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

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

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

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

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

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

    set(`a,3)

or:

    set("a",3)

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

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

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

### Variables de parámetros

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

    parameter foo = 1

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

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

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

### Retorno

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

Ejemplo:

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

### Referencias

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

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

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

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

References are best explained by an example:

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

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

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

gives us 4.

### Lvalues

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

`a`

- Identificador. Aquí se asignará la variable de nombre `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 interchangably. 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.

## Programación avanzada con GEL

### Control de errores

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

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

    function f(M) = (
      if not IsMatrix (M) then (
        error ("M no es una matriz");
        bailout
      );
      ...
    )

### Sintaxis de nivel superior

The synatax 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 sequence of lines as if 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 of course part of several statements inside parentheses).

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 Algo() then
      HacerAlgo()
    else
      HacerOtraCosa()

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 Algo() then (
      HacerAlgo()
    ) else (
      HacerOtraCosa()
    )

### Devolver funciones

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 when 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.

### Variables locales verdaderas

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 refereced variables (except for function arguments) to a `null`.

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

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

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

### Procedimiento de inicio de GEL

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

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

### Cargar programas

Sometimes you have a larger program that you wrote into a file and want to read in that file. 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 similiar 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 programa1.gel programa2.gel
    load "Nombre raro de archivo con ESPACIOS.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 «carpeta_con_programas_gel»
    ls *.gel

## Matrices en GEL

Genius tiene soporte para vectores y matrices y una biblioteca dimensionable para manipulación de matrices y funciones de álgebra lineal.

### Introducir matrices

To enter matrixes, 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 matricies. 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]

similiarly you can build matricies out of vectors and other stuff like that.

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

    [1, 2, 3
     4, 5
     6]

will end up being

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

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

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

### Conjugada de la traspuesta y operador de trasposición

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

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

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

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

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

### Álgebra lineal

Genius implementa varias rutinas útiles para manipular álgebra lineal y matrices. Consulte las secciones álgebra lineal y manipulación de matrices de la lista de funciones GEL.

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

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

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

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

## Polinomios en GEL

Currently Genius can handle polynomials of one variable written out as vectors, and do some basic operations with these. It is planned to expand this support further.

### Usar polinomios

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

    [1,2,3]

translates to a polynomial of

    1 + 2*x + 3*x^2

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

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

gives

    3*y^2 + 2*y + 1

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

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

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

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

## Teoría de conjuntos en GEL

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

### Usar conjuntos

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

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

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

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

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

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

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

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

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

## Lista de funciones GEL

Para obtener ayuda sobre una función específica desde la consola, escriba:

    help NombreFuncion

### Comandos

help

-     help

      ayuda NombreFunción

  Imprimir ayuda (o ayuda en una función/comando).

load

-     load «archivo.gel»

  Cargar un archivo en el intérprete. El archivo se ejecutará como si se hubiera escrito en la línea de comandos.

cd

-     cd /carpeta/nombre

  Cambiar la carpeta de trabajo a `/carpeta/nombre`.

pwd

-     pwd

  Imprimir la carpeta de trabajo actual.

ls

-     ls

  Listar archivos en la carpeta actual.

plugin

-     plugin nombre_del_complemento

  Cargar un complemento. El complemento debe estar instalado en el sistema en la carpeta adecuada.

### Básico

AskButtons

-     AskButtons (consulta)

      AskButtons (consulta, botón1, ...)

  Asks a question and presents a list of buttons to the user (or a menu of options in text mode). Returns the 1-based index of the button pressed. That is, returns 1 if the first button was pressed, 2 if the second button was pressed, and so on. If the user closes the window (or simply hits enter in text mode), then `null` is returned. The execution of the program is blocked until the user responds.

AskString

-     AskString (consulta)

      AskString (consulta, predeterminado)

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

Compose

-     Compose (f,g)

  Componer dos funciones y devolver una función, que es la composición de `f` y `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 (cadena)

  Analiza y evalúa una cadena.

GetCurrentModulo

-     GetCurrentModulo

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

Identity

-     Identity (x)

  Función identidad, devuelve su argumento.

IntegerFromBoolean

-     IntegerFromBoolean (bval)

  Make integer (0 for `false` or 1 for `true`) from a boolean value. `bval` can also be a number in which case a non-zero value will be interpreted as `true` and zero will be interpreted as `false`.

IsBoolean

-     IsBoolean (arg)

  Comprobar si el argumento es un booleano (y no un número).

IsDefined

-     IsDefined (id)

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

IsFunction

-     IsFunction (arg)

  Comprobar si el argumento es una función.

IsFunctionOrIdentifier

-     IsFunctionOrIdentifier (arg)

  Comprobar si el argumento es una función o un identificador.

IsFunctionRef

-     IsFunctionRef (arg)

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

IsMatrix

-     IsMatrix (arg)

  Check if argument is a matrix. Even though `null` is sometimes considered an empty matrix, the function `IsMatrix` does not consider `null` a matrix.

IsNull

-     IsNull (arg)

  Check if argument is a `null`.

IsString

-     IsString (arg)

  Comprobar si el argumento es una cadena de texto.

IsValue

-     IsValue (arg)

  Comprobar si el argumento es un número.

Parse

-     Parse (cadena)

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

SetFunctionFlags

-     SetFunctionFlags (id,opciones...)

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

SetHelp

-     SetHelp (id,categoria,desc)

  Establece la categoría y la línea de descripción de la ayuda para una función.

SetHelpAlias

-     SetHelpAlias (id,alias)

  Establece un alias de ayuda.

chdir

-     chdir (carpeta)

  Cambia la carpeta actual, igual que `cd`.

display

-     display (cadena,expresión)

  Muestra una cadena y una expresión separadas por dos puntos.

error

-     error (cadena)

  Imprime un error en el flujo de error (en la consola).

exit

-     exit

  Aliases: `quit`

  Sale el programa.

false

-     false

  Alias: `False` `FALSE`

  The `false` boolean value.

manual

-     manual

  Muestra el manual de usuario.

print

-     print (cadena)

  Prints an expression and then print a newline. The argument `str` can be any expression. It is made into a string before being printed.

printn

-     printn (cad)

  Prints an expression without a trailing newline. The argument `str` can be any expression. It is made into a string before being printed.

protect

-     protect (id)

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

ProtectAll

-     ProtectAll ()

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

set

-     set (id,val)

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

      set(`x,1)

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

string

-     string (s)

  Crear una cadena. Esto creará una cadena desde cualquier argumento.

true

-     true

  Alias: `True` `TRUE`

  The `true` boolean value.

undefine

-     undefine (id)

  Alias: `Undefine`

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

UndefineAll

-     UndefineAll ()

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

unprotect

-     unprotect (id)

  Unprotect a variable from being modified.

UserVariables

-     UserVariables ()

  Devolver un vector con todos los nombres de variables globales definidas por el usuario (sin proteger).

wait

-     wait (secs)

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

version

-     version

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

warranty

-     warranty

  Da la información de garantía.

### Parámetros

ChopTolerance

-     ChopTolerance = número

  Tolerancia de la función `Chop`

ContinuousNumberOfTries

-     ContinuousNumberOfTries = número

  Iteraciones para tratar de obtener el límite de continuidad y sus límites.

ContinuousSFS

-     ContinuousSFS = número

  Número de pasos sucesivos dentro de la tolerancia para el cálculo de la continuidad.

ContinuousTolerance

-     ContinuousTolerance = número

  Tolerancia para la continuidad de las funciones y para el cálculo del límite.

DerivativeNumberOfTries

-     DerivativeNumberOfTries = número

  Número de iteraciones para tratar de obtener el límite para la derivada.

DerivativeSFS

-     DerivativeSFS = número

  Número de pasos sucesivos dentro de la tolerancia para el cálculo de la derivada.

DerivativeTolerance

-     DerivativeTolerance = número

  Tolerancia para calcular las derivadas de las funciones.

ErrorFunctionTolerance

-     ErrorFunctionTolerance = número

  Tolerancia de `ErrorFunction`.

FloatPrecision

-     FloatPrecision = número

  Precisión en coma flotante.

FullExpressions

-     FullExpressions = booleano

  Imprimir expresiones completas, incluso si son de más de una línea.

GaussDistributionTolerance

-     GaussDistributionTolerance = número

  Tolerancia de la función `GaussDistribution`

IntegerOutputBase

-     IntegerOutputBase = número

  Base de salida de enteros.

IsPrimeMillerRabinReps

-     IsPrimeMillerRabinReps = número

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

LinePlotDrawLegends

-     LinePlotDrawLegends = true

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

LinePlotVariableNames

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

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

LinePlotWindow

-     LinePlotWindow = [x1,x2,y1,y2]

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

MaxDigits

-     MaxDigits = número

  Máximo de cifras que mostrar.

MaxErrors

-     MaxErrors = número

  Máximo de errores que mostrar.

MixedFractions

-     MixedFractions = booleano

  Si es cierto, las fracciones mixtas se imprimen.

NumericalIntegralFunction

-     NumericalIntegralFunction = función

  La función usada para la integración en`NumericalIntegral`.

NumericalIntegralSteps

-     NumericalIntegralSteps = número

  Pasos que realizar en `NumericalIntegral`.

OutputChopExponent

-     OutputChopExponent = número

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

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

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

OutputChopWhenExponent

-     OutputChopWhenExponent = número

  When to chop output. See `OutputChopExponent`.

OutputStyle

-     OutputStyle = cadena

  Estilo de salida, puede ser `normal`, `latex`, `mathml` o `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 = booleano

  Convertir todos los resultados a flotantes antes de imprimir.

ScientificNotation

-     ScientificNotation = booleano

  Usar notación científica.

SlopefieldTicks

-     SlopefieldTicks = [vertical,horizontal]

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

SumProductNumberOfTries

-     SumProductNumberOfTries = número

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

SumProductSFS

-     SumProductSFS = número

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

SumProductTolerance

-     SumProductTolerance = número

  Tolerance for `InfiniteSum` and `InfiniteProduct`.

SurfacePlotVariableNames

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

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

SurfacePlotWindow

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

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

VectorfieldNormalized

-     VectorfieldNormalized = true

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

VectorfieldTicks

-     VectorfieldTicks = [vertical,horizontal]

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

### Constantes

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.

  Consulte la Mathworld para obtener más información.

EulerConstant

-     EulerConstant

  Alias: `gamma`

  Constante gamma de Euler. También llamada constante de Euler-Mascheroni,

  Consulte la Wikipedia o Planetmath o Mathworld para obtener más información.

GoldenRatio

-     GoldenRatio

  El número áureo.

  Consulte la Wikipedia o Planetmath o Mathworld para obtener más información.

Gravedad

-     Gravedad

  Aceleración en caída libre a nivel del mar.

  Consulte la Wikipedia para obtener más información.

e

-     e

  The base of the natural logarithm. `e^x` is the exponential function `exp`. This is the number approximately 2.71828182846...

  Consulte la Wikipedia o Planetmath o Mathworld para obtener más información.

pi

-     pi

  El número pi, que es la relación de la circunferencia de un círculo con su diámetro. Esto es aproximadamente 3,14159265359...

  Consulte la Wikipedia o Planetmath o Mathworld para obtener más información.

### Numérico

AbsoluteValue

-     AbsoluteValue (x)

  Alias: `abs`

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

  Consulte la Wikipedia, Planetmath (valor absoluto), Planetmath (módulo), Mathworld (valor absoluto) o Mathworld (módulo complejo) para obtener más información.

Chop

-     Chop (x)

  Reemplazar números muy pequeños por cero.

ComplexConjugate

-     ComplexConjugate (z)

  Alias: `conj` `Conj`

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

  Consulte la Wikipedia para obtener más información.

Denominator

-     Denominator (x)

  Obtener el denominador de un número racional.

  Consulte la Wikipedia para obtener más información.

FractionalPart

-     FractionalPart (x)

  Devolver la parte fraccional de un número.

  Consulte la Wikipedia para obtener más información.

Im

-     Im (z)

  Alias: `ImaginaryPart`

  Obtener la parte imaginaria de un número complejo.

  Consulte la Wikipedia para obtener más información.

IntegerQuotient

-     IntegerQuotient (m,n)

  División sin resto.

IsComplex

-     IsComplex (num)

  Comprobar si el argumento es un número complejo (no real).

IsComplexRational

-     IsComplexRational (num)

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

IsFloat

-     IsFloat (num)

  Comprobar si el argumento es un número en coma flotante (no complejo).

IsGaussInteger

-     IsGaussInteger (num)

  Alias: `IsComplexInteger`

  Comprobar si el argumento es un posible entero complejo.

IsInteger

-     IsInteger (num)

  Comprobar si el argumento es un entero (no complejo).

IsNonNegativeInteger

-     IsNonNegativeInteger (num)

  Comprobar si el argumento es un entero real no negativo.

IsPositiveInteger

-     IsPositiveInteger (num)

  Alias: `IsNaturalNumber`

  Check if argument is a positive real integer. Note that we accept the convention that 0 is not a natural number.

IsRational

-     IsRational (num)

  Check if argument is a rational number (non-complex). Of course rational simply means "not stored as a floating point number."

IsReal

-     IsReal (num)

  Comprobar si el argumento es un número real

Numerator

-     Numerator (x)

  Obtener el numerador de un número racional.

  Consulte la Wikipedia para obtener más información.

Re

-     Re (z)

  Alias: `RealPart`

  Obtener la parte real de un número complejo.

  Consulte la Wikipedia para obtener más información.

Sign

-     Sign (x)

  Alias: `sign`

  Return the sign of a number. That is returns `-1` if value is negative, `0` if value is zero and `1` if value is positive. If `x` is a complex value then `Sign` returns the direction or 0.

ceil

-     ceil (x)

  Alias: `Ceiling`

  Obtener el entero más bajo mayor o igual que n.

exp

-     exp (x)

  The exponential function. This is the function `e^x` where `e` is the base of the natural logarithm.

  Consulte la Wikipedia o Planetmath o Mathworld para obtener más información.

float

-     float (x)

  Make number a floating point value. That is returns the floating point representation of the number `x`.

floor

-     floor (x)

  Alias: `Floor`

  Get the highest integer less than or equal to `n`.

ln

-     ln (x)

  El logaritmo natural, logaritmo en base `e`.

log

-     log (x)

      log (x,b)

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

log10

-     log10 (x)

  Logaritmo de `x` en base 10.

log2

-     log2 (x)

  Alias: `lg`

  Logaritmo de `x` en base 2.

max

-     max (a,args...)

  Alias: `Max` `Maximum`

  Devuelve el máximo de los argumentos o las matrices.

min

-     min (a,args...)

  Alias: `Min` `Minimum`

  Devuelve el mínimo de los argumentos o las matrices.

rand

-     rand (size...)

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

randint

-     randint (max,size...)

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

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

round

-     round (x)

  Alias: `Round`

  Redondear un número.

sqrt

-     sqrt (x)

  Alias: `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

  Consulte Planetmath para obtener más información.

trunc

-     trunc (x)

  Alias: `Truncate` `IntegerPart`

  Truncar el número a un entero (devolver la parte entera)

### Trigonometría

acos

-     acos (x)

  Alias: `arccos`

  La función arccos (inversa del cos).

acosh

-     acosh (x)

  Alias: `arccosh`

  La función arccosh (inversa del cosh).

acot

-     acot (x)

  Alias: `arccot`

  La función arccot (inversa de la cot)

acoth

-     acoth (x)

  Alias: `arccoth`

  La función arccoth (inversa de la coth).

acsc

-     acsc (x)

  Alias: `arccsc`

  La inversa de la función cosecante.

acsch

-     acsch (x)

  Alias: `arccsch`

  La inversa de la función cosecante hiperbólica.

asec

-     asec (x)

  Alias: `arcsec`

  La inversa de la función secante.

asech

-     asech (x)

  Alias: `arcsech`

  La inversa de la función secante hiperbólica.

asin

-     asin (x)

  Alias: `arcsin`

  La función arcsen (inversa del sen).

asinh

-     asinh (x)

  Alias: `arcsinh`

  La función arcsenh (inversa del senh).

atan

-     atan (x)

  Alias: `arctan`

  Calcula la función «arctan» (inversa de «tan»).

  Consulte la Wikipedia o Mathworld para obtener más información.

atanh

-     atanh (x)

  Alias: `arctanh`

  La función arctanh (inversa de la tanh).

atan2

-     atan2 (y, x)

  Alias: `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 then failing.

  Consulte la Wikipedia o Mathworld para obtener más información.

cos

-     cos (x)

  Calcula la función coseno.

  Consulte Planetmath para obtener más información.

cosh

-     cosh (x)

  Calcula la función coseno hiperbólico.

  Consulte Planetmath para obtener más información.

cot

-     cot (x)

  La función cotangente.

  Consulte Planetmath para obtener más información.

coth

-     coth (x)

  La función cotangente hiperbólica.

  Consulte Planetmath para obtener más información.

csc

-     csc (x)

  La función cosecante.

  Consulte Planetmath para obtener más información.

csch

-     csch (x)

  La función cosecante hiperbólica.

  Consulte Planetmath para obtener más información.

sec

-     sec (x)

  La función secante.

  Consulte Planetmath para obtener más información.

sech

-     sech (x)

  La función secante hiperbólica.

  Consulte Planetmath para obtener más información.

sin

-     sin (x)

  Calcula la función seno.

  Consulte Planetmath para obtener más información.

sinh

-     sinh (x)

  Calcula la función seno hiperbólico.

  Consulte Planetmath para obtener más información.

tan

-     tan (x)

  Calcula la función tangente.

  Consulte Planetmath para obtener más información.

tanh

-     tanh (x)

  La función tangente hiperbólica.

  Consulte Planetmath para obtener más información.

### Teoría de números

AreRelativelyPrime

-     AreRelativelyPrime (a,b)

  ¿Son los números reales `a` and `b` primos entre sí? Devuelve `true` o `false`.

  Consulte Planetmath o Mathworld para obtener más información.

BernoulliNumber

-     BernoulliNumber (n)

  Devolver el `n`-ésimo número de Bernoulli.

  Consulte la Wikipedia o Mathworld para obtener más información.

ChineseRemainder

-     ChineseRemainder (a,m)

  Alias: `CRT`

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

  Consulte la Wikipedia o Planetmath o Mathworld para obtener más información.

CombineFactorizations

-     CombineFactorizations (a,b)

  Dadas dos factorizaciones, dar la factorización del producto.

  Consulte la secciónfactorizar.

ConvertFromBase

-     ConvertFromBase (v,b)

  Convertir un vector de valores mostrando potencias de b a un número.

ConvertToBase

-     ConvertToBase (n,b)

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

DiscreteLog

-     DiscreteLog (n,b,q)

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

  Consulte la Wikipedia o Planetmath o Mathworld para obtener más información.

Divides

-     Divides (m,n)

  Checks divisibility (if `m` divides `n`).

EulerPhi

-     EulerPhi (n)

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

  Consulte la Wikipedia o Planetmath o Mathworld para obtener más información.

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 of course 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]

  Consulte la Wikipedia para obtener más información.

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 for example to print all the perfect numbers (those that are sums of their factors) up to the number 1000 you could do (this is of course very inefficient)

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

FermatFactorization

-     FermatFactorization (n,tries)

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

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

  Consulte la Wikipedia para obtener más información.

FindPrimitiveElementMod

-     FindPrimitiveElementMod (q)

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

FindRandomPrimitiveElementMod

-     FindRandomPrimitiveElementMod (q)

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

IndexCalculus

-     IndexCalculus (n,b,q,S)

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

IndexCalculusPrecalculation

-     IndexCalculusPrecalculation (b,q,S)

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

IsEven

-     IsEven (n)

  Comprueba si un entero es par.

IsMersennePrimeExponent

-     IsMersennePrimeExponent (p)

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

  Consulte la Wikipedia, Planetmath, Mathworld o GIMPSpara obtener más información.

IsNthPower

-     IsNthPower (m,n)

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

IsOdd

-     IsOdd (n)

  Comprueba su un entero es impar.

IsPerfectPower

-     IsPerfectPower (n)

  Check an integer is any perfect power, ab.

IsPerfectSquare

-     IsPerfectSquare (n)

  Check an integer for being a perfect square of an integer. The number must be a real integer. Negative integers are of course never perfect squares of real 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.

  Consulte Planetmath o Mathworld para obtener más información.

IsPrimitiveMod

-     IsPrimitiveMod (g,q)

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

IsPrimitiveModWithPrimeFactors

-     IsPrimitiveModWithPrimeFactors (g,q,f)

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

IsPseudoprime

-     IsPseudoprime (n,b)

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

IsStrongPseudoprime

-     IsStrongPseudoprime (n,b)

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

Jacobi

-     Jacobi (a,b)

  Alias: `JacobiSymbol`

  Calcular el símbolo de Jacobi (a/b) (b debe ser impar).

JacobiKronecker

-     JacobiKronecker (a,b)

  Alias: `JacobiKroneckerSymbol`

  Calcular el símbolo de Jacobi (a/b) con extensión de Kronecker (a/2)=(2/a) cuando sea impar, o (a/2)=0 cuando sea par.

LeastAbsoluteResidue

-     LeastAbsoluteResidue (a,n)

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

Legendre

-     Legendre (a,p)

  Alias: `LegendreSymbol`

  Calcular el símbolo de Legendre (a/p).

  Consulte Planetmath o Mathworld para obtener más información.

LucasLehmer

-     LucasLehmer (p)

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

  Consulte la Wikipedia o Planetmath o Mathworld para obtener más información.

LucasNumber

-     LucasNumber (n)

  Devuelve el `n`-ésimo número de Lucas.

  Consulte la Wikipedia o Planetmath o Mathworld para obtener más información.

MaximalPrimePowerFactors

-     MaximalPrimePowerFactors (n)

  Devuelve todos los factores primos de un número.

MersennePrimeExponents

-     MersennePrimeExponents

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

  Consulte la Wikipedia, Planetmath, Mathworld o GIMPSpara obtener más información.

MillerRabinTest

-     MillerRabinTest (n,reps)

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

  Consulte la Wikipedia o Planetmath o Mathworld para obtener más información.

MillerRabinTestSure

-     MillerRabinTestSure (n)

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

  Consulte la Wikipedia o Planetmath o Mathworld para obtener más información.

ModInvert

-     ModInvert (n,m)

  Devuelve el inverso de n módulo m.

  Consulte Mathworld para obtener más información.

MoebiusMu

-     MoebiusMu (n)

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

  Consulte Planetmath o Mathworld para obtener más información.

NextPrime

-     NextPrime (n)

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

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

  Consulte Planetmath o Mathworld para obtener más información.

PadicValuation

-     PadicValuation (n,p)

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

  Consulte Planetmath para obtener más información.

PowerMod

-     PowerMod (a,b,m)

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

Prime

-     Prime (n)

  Alias: `prime`

  Devuelve el `n`-ésimo primo (hasta un límite).

  Consulte Planetmath o Mathworld para obtener más información.

PrimeFactors

-     PrimeFactors (n)

  Devuelve todos los factores primos de un número como un vector.

  Consulte Mathworld para obtener más información.

PseudoprimeTest

-     PseudoprimeTest (n,b)

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

  Consulte Planetmath o Mathworld para obtener más información.

RemoveFactor

-     RemoveFactor (n,m)

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

  Consulte Planetmath o Mathworld para obtener más información.

SilverPohligHellmanWithFactorization

-     SilverPohligHellmanWithFactorization (n,b,q,f)

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

SqrtModPrime

-     SqrtModPrime (n,p)

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

  Consulte Planetmath o Mathworld para obtener más información.

StrongPseudoprimeTest

-     StrongPseudoprimeTest (n,b)

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

  Consulte Planetmath o Mathworld para obtener más información.

gcd

-     gcd (a,args...)

  Alias: `GCD`

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

  Consulte Planetmath o Mathworld para obtener más información.

lcm

-     lcm (a,args...)

  Alias: `LCM`

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

  Consulte Planetmath o Mathworld para obtener más información.

### Manipulación de matrices

ApplyOverMatrix

-     ApplyOverMatrix (a,func)

  Aplicar una función sobre todos los elementos de una matriz y devolver una matriz con los resultados.

ApplyOverMatrix2

-     ApplyOverMatrix2 (a,b,func)

  Aplicar una función sobre todos los elementos de dos matrices (o un valor y una matriz) y devolver una matriz con los resultados.

ColumnsOf

-     ColumnsOf (M)

  Obtiene las columnas de una matriz como un vector horizontal.

ComplementSubmatrix

-     ComplementSubmatrix (m,r,c)

  Eliminar filas y columnas de una matriz.

CompoundMatrix

-     CompoundMatrix (k,A)

  Calcular la k-ésima matriz compuesta de A.

CountZeroColumns

-     CountZeroColumns (M)

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

DeleteColumn

-     DeleteColumn (M,col)

  Elimina una columna de una matriz.

DeleteRow

-     DeleteRow (M,row)

  Elimina una fila de una matriz.

DiagonalOf

-     DiagonalOf (M)

  Obtiene las entradas diagonales de una matriz como un vector columna.

  Consulte la Wikipedia para obtener más información.

DotProduct

-     DotProduct (u,v)

  Get the dot product of two vectors. The vectors must be of the same size. No conjugates are taken so this is a bilinear form even if working over the complex numbers.

  Consulte Planetmath para obtener más información.

ExpandMatrix

-     ExpandMatrix (M)

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

HermitianProduct

-     HermitianProduct (u,v)

  Alias: `InnerProduct`

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

  Consulte Mathworld para obtener más información.

I

-     I (n)

  Alias: `eye`

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

  Consulte Planetmath para obtener más información.

IndexComplement

-     IndexComplement (vec,msize)

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

IsDiagonal

-     IsDiagonal (M)

  Es una matriz diagonal.

  Consulte la Wikipedia o Planetmath para obtener más información.

IsIdentity

-     IsIdentity (x)

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

IsLowerTriangular

-     IsLowerTriangular (M)

  Is a matrix lower triangular. That is, are all the entries above the diagonal zero.

IsMatrixInteger

-     IsMatrixInteger (M)

  Comprobar si una matriz es una matriz de enteros (no compleja).

IsMatrixNonnegative

-     IsMatrixNonnegative (M)

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

  Consulte la Wikipedia para obtener más información.

IsMatrixPositive

-     IsMatrixPositive (M)

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

  Consulte la Wikipedia para obtener más información.

IsMatrixRational

-     IsMatrixRational (M)

  Comprobar si el argumento es una matriz de números racionales (no complejos)

IsMatrixReal

-     IsMatrixReal (M)

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

IsMatrixSquare

-     IsMatrixSquare (M)

  Check if a matrix is square, that is its width is equal to its height.

IsUpperTriangular

-     IsUpperTriangular (M)

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

IsValueOnly

-     IsValueOnly (M)

  Check if a matrix is a matrix of numbers only. Many internal functions make this check. Values can be any number including complex numbers.

IsVector

-     IsVector (v)

  Is argument a horizontal or a vertical vector. Genius does not distinguish between a matrix and a vector and a vector is just a 1 by `n` or `n` by 1 matrix.

IsZero

-     IsZero (x)

  Check if a matrix is composed of all zeros. Also works on numbers, in which case it is equivalent to `x==0`. When `x` is `null` (we could think of that as a 0 by 0 matrix), no error is generated and `true` is returned as the condition is vacuous.

LowerTriangular

-     LowerTriangular (M)

  Returns a copy of the matrix `M` with all the entries above the diagonal set to zero.

MakeDiagonal

-     MakeDiagonal (v,arg...)

  Alias: `diag`

  Hacer una matriz diagonal de un vector.

  Consulte la Wikipedia o Planetmath para obtener más información.

MakeVector

-     MakeVector (A)

  Make column vector out of matrix by putting columns above each other. Returns `null` when given `null`.

MatrixProduct

-     MatrixProduct (A)

  Calculate the product of all elements in a matrix or vector. That is we multiply all the elements and return a number that is the product of all the elements.

MatrixSum

-     MatrixSum (A)

  Calculate the sum of all elements in a matrix or vector. That is we add all the elements and return a number that is the sum of all the elements.

MatrixSumSquares

-     MatrixSumSquares (A)

  Calculate the sum of squares of all elements in a matrix or vector.

OuterProduct

-     OuterProduct (u,v)

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

ReverseVector

-     ReverseVector (v)

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

RowSum

-     RowSum (m)

  Calculate sum of each row in a matrix and return a vertical vector with the result.

RowSumSquares

-     RowSumSquares (m)

  Calcular la suma de los cuadrados de cada fila de una matriz.

RowsOf

-     RowsOf (M)

  Gets the rows of a matrix as a vertical vector. Each element of the vector is a horizontal vector which 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,filas,columnas)

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

ShuffleVector

-     ShuffleVector (v)

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

SortVector

-     SortVector (v)

  Ordenar los elementos del vector en orden ascendente.

StripZeroColumns

-     StripZeroColumns (M)

  Quita todas las columnas de ceros de `M`.

StripZeroRows

-     StripZeroRows (M)

  Quita todas las filas de ceros de `M`.

Submatrix

-     Submatrix (m,r,c)

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

SwapRows

-     SwapRows (m,fila1,fila2)

  Intercambiar dos columnas de una matriz.

UpperTriangular

-     UpperTriangular (M)

  Returns a copy of the matrix `M` with all the entries below the diagonal set to zero.

columns

-     columns (M)

  Obtener el número de columnas de una matriz.

elements

-     elements (M)

  Get the total number of elements of a matrix. This is the number of columns times the number of rows.

ones

-     ones (filas,columnas...)

  Make an matrix of all ones (or a row vector if only one argument is given). Returns `null` if either rows or columns are zero.

rows

-     rows (M)

  Obtener el número de filas de una matriz.

zeros

-     zeros (filas,columnas...)

  Make a matrix of all zeros (or a row vector if only one argument is given). Returns `null` if either rows or columns are zero.

### Álgebra lineal

AuxiliaryUnitMatrix

-     AuxiliaryUnitMatrix (n)

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

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

BilinearForm

-     BilinearForm (v,A,w)

  Evaluar (v,w) con respecto a la forma bilineal dada por la matriz A.

BilinearFormFunction

-     BilinearFormFunction (A)

  Devolver una función que evalúa dos vectores con respecto a la forma bilineal dada por A.

CharacteristicPolynomial

-     CharacteristicPolynomial (M)

  Alias: `CharPoly`

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

  Consulte Planetmath para obtener más información.

CharacteristicPolynomialFunction

-     CharacteristicPolynomialFunction (M)

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

  Consulte Planetmath para obtener más información.

ColumnSpace

-     ColumnSpace (M)

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

CommutationMatrix

-     CommutationMatrix (m, n)

  Devolver la matriz de conmutación K(m,n) que es la única matriz m*n por m*n tal que K(m,n) * MakeVector(A) = MakeVector(A.') para todas las matrices A m por n.

CompanionMatrix

-     CompanionMatrix (p)

  Matriz acompañante de un polinomio (como vector).

ConjugateTranspose

-     ConjugateTranspose (M)

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

  Consulte Planetmath para obtener más información.

Convolution

-     Convolution (a,b)

  Alias: `convol`

  Calcular la convolución de dos vectores horizontales.

ConvolutionVector

-     ConvolutionVector (a,b)

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

CrossProduct

-     CrossProduct (v,w)

  CrossProduct of two vectors in R3 as a column vector.

DeterminantalDivisorsInteger

-     DeterminantalDivisorsInteger (M)

  Get the determinantal divisors of an integer matrix (not its characteristic).

DirectSum

-     DirectSum (M,N...)

  Suma directa de matrices.

DirectSumMatrixVector

-     DirectSumMatrixVector (v)

  Suma directa de un vector de matrices.

Eigenvalues

-     Eigenvalues (M)

  Alias: `eig`

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

  Consulte la Wikipedia o Planetmath o Mathworld para obtener más información.

Eigenvectors

-     Eigenvectors (M)

      Eigenvectors (M, &eigenvalues)

      Eigenvectors (M, &eigenvalues, &multiplicities)

  Obtener los autovectores de una matriz cuadrada. Opcionalmente, obtener los autovalores y su multiplicidad algebraica. Actualmente funciona sólo para matrices de hasta 2x2.

  Consulte la Wikipedia o Planetmath o Mathworld para obtener más información.

GramSchmidt

-     GramSchmidt (v,B...)

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

  Consulte Planetmath para obtener más información.

HankelMatrix

-     HankelMatrix (c,r)

  Hankel matrix.

HilbertMatrix

-     HilbertMatrix (n)

  Matriz de Hilbert de orden `n`.

  Consulte Planetmath para obtener más información.

Image

-     Image (T)

  Obtener la imagen (espacio columna) de una transformación lineal.

InfNorm

-     InfNorm (v)

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

InvariantFactorsInteger

-     InvariantFactorsInteger (M)

  Get the invariant factors of a square integer matrix (not its characteristic).

InverseHilbertMatrix

-     InverseHilbertMatrix (n)

  Inverse Hilbert matrix of order `n`.

  Consulte Planetmath para obtener más información.

IsHermitian

-     IsHermitian (M)

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

  Consulte Planetmath para obtener más información.

IsInSubspace

-     IsInSubspace (v,W)

  Comprueba si un vector está en un subespacio.

IsInvertible

-     IsInvertible (n)

  Is a matrix (or number) invertible (Integer matrix is invertible iff it's invertible over the integers).

IsInvertibleField

-     IsInvertibleField (n)

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

IsNormal

-     IsNormal (M)

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

  Consulte Planetmath o Mathworld para obtener más información.

IsPositiveDefinite

-     IsPositiveDefinite (M)

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

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

  Consulte Planetmath o Mathworld para obtener más información.

IsPositiveSemidefinite

-     IsPositiveSemidefinite (M)

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

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

  Consulte Planetmath o Mathworld para obtener más información.

IsSkewHermitian

-     IsSkewHermitian (M)

  Es matriz antihermítica. Esto es, la transposición conjugada es igual al negativo de la matriz.

  Consulte Planetmath para obtener más información.

IsUnitary

-     IsUnitary (M)

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

  Consulte Planetmath o Mathworld para obtener más información.

JordanBlock

-     JordanBlock (n,lambda)

  Alias: `J`

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

  Consulte Planetmath o Mathworld para obtener más información.

Kernel

-     Kernel (T)

  Obtener el núcleo (espacio nulo) de una trasformación lineal.

  (See NullSpace)

LUDecomposition

-     LUDecomposition (A, L, U)

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

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

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

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

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

  Consulte Planetmath o Mathworld para obtener más información.

Minor

-     Minor (M,i,j)

  Obtener el menor `i`-`j` de una matriz.

  Consulte Planetmath para obtener más información.

NonPivotColumns

-     NonPivotColumns (M)

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

Norm

-     Norm (v,p...)

  Alias: `norm`

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

NullSpace

-     NullSpace (T)

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

  Consulte Planetmath para obtener más información.

Nullity

-     Nullity (M)

  Alias: `nullity`

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

  Consulte Planetmath para obtener más información.

OrthogonalComplement

-     OrthogonalComplement (M)

  Obtener el complemento ortogonal del espacio de columnas.

PivotColumns

-     PivotColumns (M)

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

Projection

-     Projection (v,W,B...)

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

QRDecomposition

-     QRDecomposition (A, Q)

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

      genius> R = QRDecomposition(A,&Q)

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

  Consulte Planetmath o Mathworld para obtener más información.

RayleighQuotient

-     RayleighQuotient (A,x)

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

  Consulte Planetmath para obtener más información.

RayleighQuotientIteration

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

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

  See Planetmath for more information on Rayleigh quotient.

Rank

-     Rank (M)

  Alias: `rank`

  Obtener el rango de una matriz.

  Consulte Planetmath para obtener más información.

RosserMatrix

-     RosserMatrix ()

  Rosser matrix, a classic symmetric eigenvalue test problem.

Rotation2D

-     Rotation2D (ángulo)

  Alias: `RotationMatrix`

  Return the matrix corresponding to rotation around origin in R2.

Rotation3DX

-     Rotation3DX (ángulo)

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

Rotation3DY

-     Rotation3DY (ángulo)

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

Rotation3DZ

-     Rotation3DZ (ángulo)

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

RowSpace

-     RowSpace (M)

  Obtener una matriz base para el espacio de filas de una matriz.

SesquilinearForm

-     SesquilinearForm (v,A,w)

  Evaluar (v,w) con respecto a la forma sesquilineal dada por la matriz A.

SesquilinearFormFunction

-     SesquilinearFormFunction (A)

  Devolver una función que evalúa dos vectores con respecto a la forma sesquilineal dada por A.

SmithNormalFormField

-     SmithNormalFormField (A)

  Forma normal de Smith para campos (terminará con unos en la diagonal).

SmithNormalFormInteger

-     SmithNormalFormInteger (M)

  Forma normal de Smith para matrices cuadradas enteras (no su característica).

SolveLinearSystem

-     SolveLinearSystem (M,V,args...)

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

ToeplitzMatrix

-     ToeplitzMatrix (c, r...)

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

  Consulte Planetmath para obtener más información.

Trace

-     Trace (M)

  Alias: `trace`

  Calcular la traza de una matriz. Esto es la suma de sus elementos diagonales.

  Consulte Planetmath para obtener más información.

Transpose

-     Transpose (M)

  Traspuesta de una matriz. Es lo mismo que el operador `.'`.

  Consulte Planetmath para obtener más información.

VandermondeMatrix

-     VandermondeMatrix (v)

  Alias: `vander`

  Devuelve la matriz de Vandermonde.

VectorAngle

-     VectorAngle (v,w,B...)

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

VectorSpaceDirectSum

-     VectorSpaceDirectSum (M,N)

  The direct sum of the vector spaces M and N.

VectorSubspaceIntersection

-     VectorSubspaceIntersection (M,N)

  Intersección de subespacios dados por M y N.

VectorSubspaceSum

-     VectorSubspaceSum (M,N)

  La suma de los espacios vectoriales M y N, esto es {w | w=m+n, m en M, n en N}.

adj

-     adj (m)

  Alias: `Adjugate`

  Get the classical adjoint (adjugate) of a matrix.

cref

-     cref (M)

  Alias: `CREF` `ColumnReducedEchelonForm`

  Compute the Column Reduced Echelon Form.

det

-     det (M)

  Alias: `Determinant`

  Obtener el determinante de una matriz.

  Consulte la Wikipedia o Planetmath para obtener más información.

ref

-     ref (M)

  Alias: `REF` `RowEchelonForm`

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

  Consulte la Wikipedia o Planetmath para obtener más información.

rref

-     rref (M)

  Alias: `RREF` `ReducedRowEchelonForm`

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

  Consulte la Wikipedia o Planetmath para obtener más información.

### Combinatoria

Catalan

-     Catalan (n)

  Get `n`'th catalan number.

  Consulte Planetmath para obtener más información.

Combinations

-     Combinations (k,n)

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

DoubleFactorial

-     DoubleFactorial (n)

  Doble factorial: `n(n-2)(n-4)...`

  Consulte Planetmath para obtener más información.

Factorial

-     Factorial (n)

  Factorial: `n(n-1)(n-2)...`

  Consulte Planetmath para obtener más información.

FallingFactorial

-     FallingFactorial (n,k)

  Falling factorial: `(n)_k = n(n-1)...(n-(k-1))`

  Consulte la Planetmath para obtener más información.

Fibonacci

-     Fibonacci (x)

  Alias: `fib`

  Calculate `n`th Fibonacci number. That is the number defined recursively by `Fibonacci(n) = Fibonacci(n-1) + Fibonacci(n-2)` and `Fibonacci(1) = Fibonacci(2) = 1`.

  Consulte la Wikipedia o Planetmath o Mathworld para obtener más información.

FrobeniusNumber

-     FrobeniusNumber (v,arg...)

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

  Consulte la Mathworld para obtener más información.

GaloisMatrix

-     GaloisMatrix (regla_de_combinación)

  Matriz de Galois dada una regla de combinación lineal (a_1*x_+...+a_n*x_n=x_(n+1)).

GreedyAlgorithm

-     FrobeniusNumber (n,v)

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

  Consulte la Mathworld para obtener más información.

HarmonicNumber

-     HarmonicNumber (n,r)

  Alias: `HarmonicH`

  Harmonic Number, the `n`'th harmonic number of order `r`.

Hofstadter

-     Hofstadter (n)

  Función q(n) de Hofstadter definida por q(1)=1, q(2)=1, q(n)=q(n-q(n-1))+q(n-q(n-2)).

LinearRecursiveSequence

-     LinearRecursiveSequence (seed_values,combining_rule,n)

  Calcular la secuencia lineal recursiva usando el escalamiento de Galois.

Multinomial

-     Multinomial (v,arg...)

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

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

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

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

  Consulte Planetmath, Mathworld, o la Wikipedia para obtener más información.

NextCombination

-     NextCombination (v,n)

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

  For example with Combination 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.

Pascal

-     Pascal (i)

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

  Consulte Planetmath para obtener más información.

Permutations

-     Permutations (k,n)

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

  Consulte Mathworld o la Wikipedia para obtener más información.

RisingFactorial

-     RisingFactorial (n,k)

  Alias: `Pochhammer`

  (Puchhammer) factorial creciente: (n)_k = n(n+1)...(n+(k-1)).

  Consulte Planetmath para obtener más información.

StirlingNumberFirst

-     StirlingNumberFirst (n,m)

  Alias: `StirlingS1`

  Número de Stirling de primera clase.

  Consulte Planetmath o Mathworld para obtener más información.

StirlingNumberSecond

-     StirlingNumberSecond (n,m)

  Alias: `StirlingS2`

  Número de Stirling de segunda clase.

  Consulte Planetmath o Mathworld para obtener más información.

Subfactorial

-     Subfactorial (n)

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

Triangular

-     Triangular (nth)

  Calculate the `n`'th triangular number.

  Consulte Planetmath para obtener más información.

nCr

-     nCr (n,r)

  Alias: `Binomial`

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

  Consulte Planetmath para obtener más información.

nPr

-     nPr (n,r)

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

  Consulte Mathworld o la Wikipedia para obtener más información.

### Cálculo

CompositeSimpsonsRule

-     CompositeSimpsonsRule (f,a,b,n)

  Integrar f usando la Regla Compuesta de Simpson en el intervalo [a,b] con n subintervalos y un error de max(f'''')*h^4*(b-a)/180, n debe ser entero.

  Consulte Planetmath para obtener más información.

CompositeSimpsonsRuleTolerance

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

  Integración de F por la Regla compuesta de Simpson en el intervalo [a,b] con el número de pasos calculado por la cuarta derivada y la tolerancia deseada.

  Consulte Planetmath para obtener más información.

Derivative

-     Derivative (f,x0)

  Intentar calcular la derivada, primero simbólicamente y después numéricamente.

EvenPeriodicExtension

-     EvenPeriodicExtension (f,L)

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

  See also OddPeriodicExtension and PeriodicExtension.

FourierSeriesFunction

-     FourierSeriesFunction (a,b,L)

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

  Consulte la Wikipedia o Mathworld para obtener más información.

InfiniteProduct

-     InfiniteProduct (func,inicio,inc)

  Intenta calcular un producto infinito para una función de un sólo parámetro.

InfiniteProduct2

-     InfiniteProduct2 (func,arg,inicio,inc)

  Intenta calcular un producto infinito para una función de dos parámetros con func(arg,n)

InfiniteSum

-     InfiniteSum (func,inicio,inc)

  Intentar calcular una suma infinita para una función de un sólo parámetro.

InfiniteSum2

-     InfiniteSum2 (func,arg,inicio,inc)

  Intenta calcular una suma infinita para una función de dos parámetros con func(arg,n).

IsContinuous

-     IsContinuous (f,x0)

  Comprueba si una función real es continua en x0 calculando el límite en ese punto.

IsDifferentiable

-     IsDifferentiable (f,x0)

  Comprobar la diferenciabilidad aproximando los límites izquierdo y derecho y comparándolos.

LeftLimit

-     LeftLimit (f,x0)

  Calcular el límite por la izquierda de una función real en x0.

Limit

-     Limit (f,x0)

  Calcular el límite de una función real en x0. Intenta calcular tanto el límite por la derecha como por la izquierda.

MidpointRule

-     MidpointRule (f,a,b,n)

  Integración por la regla del punto medio.

NumericalDerivative

-     NumericalDerivative (f,x0)

  Alias: `NDerivative`

  Intentar calcular la derivada numérica.

NumericalFourierSeriesCoefficients

-     NumericalFourierSeriesCoefficients (f,L,N)

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

  Consulte la Wikipedia o Mathworld para obtener más información.

NumericalFourierSeriesFunction

-     NumericalFourierSeriesFunction (f,L,N)

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

  Consulte la Wikipedia o Mathworld para obtener más información.

NumericalFourierCosineSeriesCoefficients

-     NumericalFourierCosineSeriesCoefficients (f,L,N)

  Return a vector of coefficients of the the cosine Fourier series of `f` with half-period `L`. That is, we take `f` defined on `[0,L]` take the even periodic extension and compute the Fourier series, which only has cosine terms. The series is computed up to the `N`th harmonic. The coefficients are computed by numerical integration using `NumericalIntegral`. Note that `a@(1)` is the constant coefficient! That is, `a@(n)` refers to the term `cos(x*(n-1)*pi/L)`.

  Consulte la Wikipedia o Mathworld para obtener más información.

NumericalFourierCosineSeriesFunction

-     NumericalFourierCosineSeriesFunction (f,L,N)

  Return a function which is the cosine Fourier series of `f` with half-period `L`. That is, we take `f` defined on `[0,L]` take the even periodic extension and compute the Fourier series, which only has cosine terms. The series is computed up to the `N`th harmonic. The coefficients are computed by numerical integration using `NumericalIntegral`.

  Consulte la Wikipedia o Mathworld para obtener más información.

NumericalFourierSineSeriesCoefficients

-     NumericalFourierSineSeriesCoefficients (f,L,N)

  Return a vector of coefficients of the the sine Fourier series of `f` with half-period `L`. That is, we take `f` defined on `[0,L]` take the odd periodic extension and compute the Fourier series, which only has sine terms. The series is computed up to the `N`th harmonic. The coefficients are computed by numerical integration using `NumericalIntegral`.

  Consulte la Wikipedia o Mathworld para obtener más información.

NumericalFourierSineSeriesFunction

-     NumericalFourierSineSeriesFunction (f,L,N)

  Return a function which is the sine Fourier series of `f` with half-period `L`. That is, we take `f` defined on `[0,L]` take the odd periodic extension and compute the Fourier series, which only has sine terms. The series is computed up to the `N`th harmonic. The coefficients are computed by numerical integration using `NumericalIntegral`.

  Consulte la Wikipedia o Mathworld para obtener más información.

NumericalIntegral

-     NumericalIntegral (f,a,b)

  Integración por el conjunto de reglas en NumericalIntegralFunction de f desde «a» a «b» usando NumericalIntegralSteps pasos.

NumericalLeftDerivative

-     NumericalLeftDerivative (f,x0)

  Intentar calcular la derivada numérica por la izquierda.

NumericalLimitAtInfinity

-     NumericalLimitAtInfinity (_f,step_fun,tolerance,successive_for_success,N)

  Intentar calcular el límite de f(step_fun(i)), para i desde 1 hasta N.

NumericalRightDerivative

-     NumericalRightDerivative (f,x0)

  Intentar calcular la derivada numérica por la derecha.

OddPeriodicExtension

-     OddPeriodicExtension (f,L)

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

  Consulte también EvenPeriodicExtension y PeriodicExtension.

OneSidedFivePointFormula

-     OneSidedFivePointFormula (f,x0,h)

  Calcular la derivada de un lado usando una fórmula de 5 puntos.

OneSidedThreePointFormula

-     OneSidedThreePointFormula (f,x0,h)

  Calcular la derivada de un lado usando una fórmula de tres puntos.

PeriodicExtension

-     PeriodicExtension (f,a,b)

  Return a function which is the periodic extension of `f` defined on the interval `[a,b]` and has period `b-a`.

  Consulte también OddPeriodicExtension y EvenPeriodicExtension.

RightLimit

-     RightLimit (f,x0)

  Calcular el límite por la derecha de una función real en x0.

TwoSidedFivePointFormula

-     TwoSidedFivePointFormula (f,x0,h)

  Calcular la derivada de dos lados usando una fórmula de cinco puntos.

TwoSidedThreePointFormula

-     TwoSidedThreePointFormula (f,x0,h)

  Calcular la derivada de dos lados usando una fórmula de tres puntos.

### Funciones

Argument

-     Argument (z)

  Alias: `Arg` `arg`

  argumento (ángulo) de un número complejo.

DirichletKernel

-     DirichletKernel (n,t)

  Núcleo de Dirichlet de orden n.

DiscreteDelta

-     DiscreteDelta (v)

  Devuelve 1 si todos los elementos son cero.

ErrorFunction

-     ErrorFunction (x)

  Alias: `erf`

  La función de error, 2/sqrt(pi) * int_0^x e^(-t^2) dt.

  Consulte Planetmath para obtener más información.

FejerKernel

-     FejerKernel (n,t)

  Fejer kernel of order `n` evaluated at `t`

  Consulte Planetmath para obtener más información.

GammaFunction

-     GammaFunction (x)

  Alias: `Gamma`

  La función «Gamma». Actualmente sólo implementada para valores reales.

  Consulte Planetmath para obtener más información.

KroneckerDelta

-     KroneckerDelta (v)

  Devuelve 1 si todos los elementos son iguales.

MinimizeFunction

-     MinimizeFunction (func,x,incr)

  Buscar el primer valor donde f(x)=0.

MoebiusDiskMapping

-     MoebiusDiskMapping (a,z)

  Mapa de Moebius del disco a sí mismo mapeando a 0.

  Consulte Planetmath para obtener más información.

MoebiusMapping

-     MoebiusMapping (z,z2,z3,z4)

  Mapa de Moebius usando el radio cruzado z2,z3,z4 a 1,0 e infinito respectivamente.

  Consulte Planetmath para obtener más información.

MoebiusMappingInftyToInfty

-     MoebiusMappingInftyToInfty (z,z2,z3)

  Mapa de Moebius usando el radio cruzado tomando infinito a infinito y z2,z3 a 1 y 0 respectivamente.

  Consulte Planetmath para obtener más información.

MoebiusMappingInftyToOne

-     MoebiusMappingInftyToOne (z,z3,z4)

  Mapa de Moebius usando la relación cruzada tomando de infinito a 1 y z3,z4 a 0 e infinito respectivamente.

  Consulte Planetmath para obtener más información.

MoebiusMappingInftyToZero

-     MoebiusMappingInftyToZero (z,z2,z4)

  Mapa de Moebius usando la relación cruzada tomando de infinito a 0 y z2,z4 a 1 e infinito respectivamente.

  Consulte Planetmath para obtener más información.

PoissonKernel

-     PoissonKernel (r,sigma)

  El núcleo de Poisson en D(0,1) (no normalizado a 1, esto es, su integral es 2pi).

PoissonKernelRadius

-     PoissonKernelRadius (r,sigma)

  El núcleo de Poisson en D(0,R) (no normalizado a 1).

RiemannZeta

-     RiemannZeta (x)

  Alias: `zeta`

  La función «zeta de Riemann». Actualmente sólo implementada para valores reales.

  Consulte Planetmath para obtener más información.

UnitStep

-     UnitStep (x)

  La función escalón unitario es 0 para x<0, 1 si no. Es la integral de la función delta de Dirac. También llamada función de Heaviside.

  Consulte la Wikipedia para obtener más información.

cis

-     cis (x)

  La función `cis` es la misma que `cos(x)+1i*sin(x)`

deg2rad

-     deg2rad (x)

  Convertir grados a radianes.

rad2deg

-     rad2deg (x)

  Convertir radianes a grados.

### Resolución de ecuaciones

CubicFormula

-     CubicFormula (p)

  Compute roots of a cubic (degree 3) polynomial using the cubic formula. The polynomial should be given as a vector of coefficients. That is `4*x^3 + 2*x + 1` corresponds to the vector `[1,2,0,4]`. Returns a column vector of the three solutions. The first solution is always the real one as a cubic always has one real solution.

  Consulte Planetmath, Mathworld, o Wikipedia para obtener más información.

EulersMethod

-     EulersMethod (f,x0,y0,x1,n)

  Use classical Euler's method to numerically solve y'=f(x,y) for initial `x0`, `y0` going to `x1` with `n` increments, returns `y` at `x1`.

  Systems can be solved by just having `y` be a (column) vector everywhere. That is, `y0` can be a vector in which case `f` should take a number `x` and a vector of the same size for the second argument and should return a vector of the same size.

  Consulte Mathworld, o la Wikipedia para obtener más información.

EulersMethodFull

-     EulersMethodFull (f,x0,y0,x1,n)

  Use classical Euler's method to numerically solve y'=f(x,y) for initial `x0`, `y0` going to `x1` with `n` increments, returns a 2 by `n+1` matrix with the `x` and `y` values. Suitable for plugging into LinePlotDrawLine.

  Systems can be solved by just having `y` be a (column) vector everywhere. That is, `y0` can be a vector in which case `f` should take a number `x` and a vector of the same size for the second argument and should return a vector of the same size.

  Consulte Mathworld, o la Wikipedia para obtener más información.

FindRootBisection

-     FindRootBisection (f,a,b,TOL,N)

  Find root of a function using the bisection method. `TOL` is the desired tolerance and `N` is the limit on the number of iterations to run, 0 means no limit. The function returns a vector `[success,value,iteration]`, where `success` is a boolean indicating success, `value` is the last value computed, and `iteration` is the number of iterations done.

FindRootFalsePosition

-     FindRootFalsePosition (f,a,b,TOL,N)

  Find root of a function using the method of false position. `TOL` is the desired tolerance and `N` is the limit on the number of iterations to run, 0 means no limit. The function returns a vector `[success,value,iteration]`, where `success` is a boolean indicating success, `value` is the last value computed, and `iteration` is the number of iterations done.

FindRootMullersMethod

-     FindRootMullersMethod (f,x1,x2,x3,TOL,N)

  Find root of a function using the Muller's method. `TOL` is the desired tolerance and `N` is the limit on the number of iterations to run, 0 means no limit. The function returns a vector `[success,value,iteration]`, where `success` is a boolean indicating success, `value` is the last value computed, and `iteration` is the number of iterations done.

FindRootSecant

-     FindRootSecant (f,a,b,TOL,N)

  Find root of a function using the secant method. `TOL` is the desired tolerance and `N` is the limit on the number of iterations to run, 0 means no limit. The function returns a vector `[success,value,iteration]`, where `success` is a boolean indicating success, `value` is the last value computed, and `iteration` is the number of iterations done.

PolynomialRoots

-     PolynomialRoots (p)

  Compute roots of a polynomial (degrees 1 through 4) using one of the formulas for such polynomials. The polynomial should be given as a vector of coefficients. That is `4*x^3 + 2*x + 1` corresponds to the vector `[1,2,0,4]`. Returns a column vector of the solutions.

  The function calls QuadraticFormula, CubicFormula, and QuarticFormula.

QuadraticFormula

-     QuadraticFormula (p)

  Compute roots of a quadratic (degree 2) polynomial using the quadratic formula. The polynomial should be given as a vector of coefficients. That is `3*x^2 + 2*x + 1` corresponds to the vector `[1,2,3]`. Returns a column vector of the two solutions.

  Consulte Planetmath o Mathworld para obtener más información.

QuarticFormula

-     QuarticFormula (p)

  Compute roots of a quartic (degree 4) polynomial using the quartic formula. The polynomial should be given as a vector of coefficients. That is `5*x^4 + 2*x + 1` corresponds to the vector `[1,2,0,0,5]`. Returns a column vector of the four solutions.

  Consulte Planetmath, Mathworld, o la Wikipedia para obtener más información.

RungeKutta

-     RungeKutta (f,x0,y0,x1,n)

  Use classical non-adaptive fourth order Runge-Kutta method to numerically solve y'=f(x,y) for initial `x0`, `y0` going to `x1` with `n` increments, returns `y` at `x1`.

  Systems can be solved by just having `y` be a (column) vector everywhere. That is, `y0` can be a vector in which case `f` should take a number `x` and a vector of the same size for the second argument and should return a vector of the same size.

  Consulte Mathworld, o la Wikipedia para obtener más información.

RungeKuttaFull

-     RungeKuttaFull (f,x0,y0,x1,n)

  Use classical non-adaptive fourth order Runge-Kutta method to numerically solve y'=f(x,y) for initial `x0`, `y0` going to `x1` with `n` increments, returns a 2 by `n+1` matrix with the `x` and `y` values. Suitable for plugging into LinePlotDrawLine.

  Systems can be solved by just having `y` be a (column) vector everywhere. That is, `y0` can be a vector in which case `f` should take a number `x` and a vector of the same size for the second argument and should return a vector of the same size.

  Consulte Mathworld, o la Wikipedia para obtener más información.

### Estadísticas

Average

-     Average (m)

  Alias: `average` `Mean` `mean`

  Calcular la media de una matriz entera.

  Consulte Mathworld para obtener más información.

GaussDistribution

-     GaussDistribution (x,sigma)

  Integral of the GaussFunction from 0 to `x` (area under the normal curve).

  Consulte Mathworld para obtener más información.

GaussFunction

-     GaussFunction (x,sigma)

  La función de distribución Gausiana normalizada (la curva normal).

  Consulte Mathworld para obtener más información.

Median

-     Median (m)

  Alias: `median`

  Calcula la mediana de una matriz entera.

  Consulte Mathworld para obtener más información.

PopulationStandardDeviation

-     PopulationStandardDeviation (m)

  Alias: `stdevp`

  Calcula la desviación de población típica de una matriz completa.

RowAverage

-     RowAverage (m)

  Alias: `RowMean`

  Calcular la media de cada columna de una matriz.

  Consulte Mathworld para obtener más información.

RowMedian

-     RowMedian (m)

  Calculate median of each row in a matrix and return a column vector of the medians.

  Consulte Mathworld para obtener más información.

RowPopulationStandardDeviation

-     RowPopulationStandardDeviation (m)

  Alias: `rowstdevp`

  Calcular la desviación típica de las columnas de una matriz y devuelve una matriz columna.

RowStandardDeviation

-     RowStandardDeviation (m)

  Alias: `rowstdev`

  Calcular la desviación estándar de las filas de una matriz y devuelve una matriz columna.

StandardDeviation

-     StandardDeviation (m)

  Alias: `stdev`

  Calcular la desviación estándar de una matriz entera.

### Polinomios

AddPoly

-     AddPoly (p1,p2)

  Suma dos polinomios (vectores).

DividePoly

-     DividePoly (p,q,&r)

  Divide two polynomials (as vectors) using long division. Returns the quotient of the two polynomials. The optional argument `r` is used to return the remainder. The remainder will have lower degree than `q`.

  Consulte Planetmath para obtener más información.

IsPoly

-     IsPoly (p)

  Comprobar si un vector se puede usar como un polinomio.

MultiplyPoly

-     MultiplyPoly (p1,p2)

  Multiplica dos polinomios (como vectores).

NewtonsMethodPoly

-     NewtonsMethodPoly (poly,guess,epsilon,maxn)

  Run newton's method on a polynomial to attempt to find a root, returns after two successive values are within epsilon or after maxn tries (then returns `null`).

Poly2ndDerivative

-     Poly2ndDerivative (p)

  Tomar la derivada segunda (como vector) polinómico.

PolyDerivative

-     PolyDerivative (p)

  Tomar la derivada (como vector) polinómico.

PolyToFunction

-     PolyToFunction (p)

  Extraer una función de un polinomio (como vector).

PolyToString

-     PolyToString (p,var...)

  Extraer una cadena de un polinomio (como vector).

SubtractPoly

-     SubtractPoly (p1,p2)

  Restar dos polinomios (como vectores).

TrimPoly

-     TrimPoly (p)

  Eliminar ceros de un polinomio (como vector).

### Teoría de conjuntos

Intersection

-     Intersection (X,Y)

  Devuelve la intersección de X e Y (X e Y son vectores que se tratan como conjuntos).

IsIn

-     IsIn (x,X)

  Returns `true` if the element x is in the set X (where X is a vector pretending to be a set).

IsSubset

-     IsSubset (X, Y)

  Returns `true` if X is a subset of Y (X and Y are vectors pretending to be sets).

MakeSet

-     MakeSet (X)

  Devuelve un vector donde cada elemento de X aparece una sola vez.

SetMinus

-     SetMinus (X,Y)

  Returns a set theoretic difference X-Y (X and Y are vectors pretending to be sets).

Union

-     Union (X,Y)

  Devuelve la unión de X e Y (X e Y son vectores que se tratan como conjuntos).

### Miscelánea

ASCIIToString

-     ASCIIToString (vec)

  Convertir un vector de valores ASCII en una cadena.

AlphabetToString

-     AlphabetToString (vec,alfabeto)

  Convierte un vector de valores alfabéticos basados en 0 (posiciones en la cadena alfabeto) a una cadena.

StringToASCII

-     StringToASCII (cad)

  Convertir una cadena a un vector de valores ASCII.

StringToAlphabet

-     StringToAlphabet (str,alfabeto)

  Convertir una cadena en un vector de valores alfabéticos basados en 0 (posiciones en la cadena alfabeto), -1 para las letras desconocidas.

### Operaciones simbólicas

SymbolicDerivative

-     SymbolicDerivative (f)

  Intentar diferenciar simbólicamente la función «f», donde «f» es una función de una variable.

  Ejemplos:

      genius> SymbolicDerivative(sin)
      = (`(x)=cos(x))
      genius> SymbolicDerivative(`(x)=7*x^2)
      = (`(x)=(7*(2*x)))

SymbolicDerivativeTry

-     SymbolicDerivativeTry (f)

  Attempt to symbolically differentiate the function f, where f is a function of one variable, returns `null` if unsuccessful but is silent. (See `SymbolicDerivative`)

SymbolicNthDerivative

-     SymbolicNthDerivative (f,n)

  Attempt to symbolically differentiate a function n times. (See `SymbolicDerivative`)

SymbolicNthDerivativeTry

-     SymbolicNthDerivativeTry (f,n)

  Attempt to symbolically differentiate a function n times quietly and return `null` on failure (See `SymbolicNthDerivative`)

SymbolicTaylorApproximationFunction

-     SymbolicTaylorApproximationFunction (f,x0,n)

  Attempt to construct the taylor approximation function around x0 to the nth degree. (See `SymbolicDerivative`)

### Dibujar

LinePlot

-     LinePlot (func1,func2,func3,...)

      LinePlot (func1,func2,func3,x1,x2,y1,y2)

  Plot a function (or several functions) with a line. First up to 10 arguments are functions, then optionally you can specify the limits of the plotting window as `x1`, `x2`, `y1`, `y2`. If limits are not specified, then the currently set limits apply (See `LinePlotWindow`)

  The parameter `LinePlotDrawLegends` controls the drawing of the legend.

  Ejemplos:

      genius> LinePlot(sin,cos)
      genius> LinePlot(`(x)=x^2,-1,1,0,1)

LinePlotClear

-     LinePlotClear ()

  Show the line plot window and clear out functions and any other lines that were drawn.

LinePlotDrawLine

-     LinePlotDrawLine (x1,y1,x2,y2,...)

      LinePlotDrawLine (v,...)

  Draw a line from `x1`,`y1` to `x2`,`y2`. `x1`,`y1`, `x2`,`y2` can be replaced by an `n` by 2 matrix for a longer line.

  Extra parameters can be added to specify line color, thickness, arrows, and the plotting window. You can do this by adding a string `"color"`, `"thickness"`, `"window"`, or `"arrow"`, and after it either the color string, the thicknes as an integer, the window as 4-vector, and for arrow either `"origin"`, `"end"`, `"both"`, or `"none"`. For `"window"` we can specify `"fit"` rather than a vector in which case, the x range will be set precisely and the y range will be set with five percent borders around the line. Finally, the legend can be specified by adding `"legend"` and the string with the legend.

  Ejemplos:

      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(EulersMethodFull(`(x,y)=y,0,3,100),"color","blue","legend","The Solution")

LinePlotParametric

-     LinePlotParametric (xfunc,yfunc,...)

      LinePlotParametric (xfunc,yfunc,t1,t2,tinc)

      LinePlotParametric (xfunc,yfunc,t1,t2,tinc,x1,x2,y1,y2)

  Plot a parametric function with a line. First come the functions for `x` and `y` then optionally the `t` limits as `t1,t2,tinc`, then optionally the limits as `x1,x2,y1,y2`.

  If limits are not specified, then the currently set limits apply (See `LinePlotWindow`).

  The parameter `LinePlotDrawLegends` controls the drawing of the legend.

LinePlotCParametric

-     LinePlotCParametric (func,...)

      LinePlotCParametric (func,t1,t2,tinc)

      LinePlotCParametric (func,t1,t2,tinc,x1,x2,y1,y2)

  Plot a parametric complex valued function with a line. First comes the function that returns `x+iy`, then optionally the `t` limits as `t1,t2,tinc`, then optionally the limits as `x1,x2,y1,y2`.

  If limits are not specified, then the currently set limits apply (See `LinePlotWindow`).

  The parameter `LinePlotDrawLegends` controls the drawing of the legend.

SlopefieldClearSolutions

-     SlopefieldClearSolutions ()

  Clears the solutions drawn by the `SlopefieldDrawSolution` function.

SlopefieldDrawSolution

-     SlopefieldDrawSolution (x, y, dx)

  When a slope field plot is active, draw a solution with the specified initial condition. The standard Runge-Kutta method is used with increment `dx`. Solutions stay on the graph until a different plot is shown or until you call `SlopefieldClearSolutions`. You can also use the graphical interface to draw solutions and specify initial conditions with the mouse.

SlopefieldPlot

-     SlopefieldPlot (func)

      SlopefieldPlot (func,x1,x2,y1,y2)

  Plot a slope field. The function `func` should take two real numbers `x` and `y`, or a single complex number. Optionally you can specify the limits of the plotting window as `x1`, `x2`, `y1`, `y2`. If limits are not specified, then the currently set limits apply (See `LinePlotWindow`).

  The parameter `LinePlotDrawLegends` controls the drawing of the legend.

  Ejemplos:

      genius> Slopefield(`(x,y)=sin(x-y),-5,5,-5,5)

SurfacePlot

-     SurfacePlot (func)

      SurfacePlot (func,x1,x2,y1,y2,z1,z2)

  Plot a surface function which takes either two arguments or a complex number. First comes the function then optionally limits as `x1`, `x2`, `y1`, `y2`, `z1`, `z2`. If limits are not specified, then the currently set limits apply (See `SurfacePlotWindow`). Genius can only plot a single surface function at this time.

  Ejemplos:

      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)

VectorfieldClearSolutions

-     VectorfieldClearSolutions ()

  Clears the solutions drawn by the `VectorfieldDrawSolution` function.

VectorfieldDrawSolution

-     VectorfieldDrawSolution (x, y, dt, tlen)

  When a vector field plot is active, draw a solution with the specified initial condition. The standard Runge-Kutta method is used with increment `dt` for an interval of length `tlen`. Solutions stay on the graph until a different plot is shown or until you call `VectorfieldClearSolutions`. You can also use the graphical interface to draw solutions and specify initial conditions with the mouse.

VectorfieldPlot

-     VectorfieldPlot (funcx, funcy)

      VectorfieldPlot (funcx, funcy, x1, x2, y1, y2)

  Plot a two dimensional vector field. The function `funcx` should be the dx/dt of the vectorfield and the function `funcy` should be the dy/dt of the vectorfield. The functions should take two real numbers `x` and `y`, or a single complex number. When the parameter `VectorfieldNormalized` is `true`, then the magnitude of the vectors is normalized. That is, only the direction and not the magnitude is shown.

  Optionally you can specify the limits of the plotting window as `x1`, `x2`, `y1`, `y2`. If limits are not specified, then the currently set limits apply (See `LinePlotWindow`).

  The parameter `LinePlotDrawLegends` controls the drawing of the legend.

  Ejemplos:

      genius> VectorfieldPlot(`(x,y)=x^2-y, `(x,y)=y^2-x, -1, 1, -1, 1)

## Programas de ejemplo en 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("ref: 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
    )

## Configuración

To configure Genius Mathematics Tool, choose Settings Preferences. There are several basic parameters provided by the calculator in addition to the ones provided by the standard library. These control how the calculator behaves.

### Changing Settings with GEL

Many of the settings in Genius are simply global variables, and can be evaluated and assigned to in the same way as normal variables. See genius-gel-variables about evaluating and assigning to variables, and genius-gel-function-parameters for a list of settings that can be modified in this way.

As an example, you can set the maximum number of digits in a result to 12 by typing:

    MaxDigits = 12

### Salida

Número máximo de cifras que mostrar

- The maximum digits in a result (`MaxDigits`)

Resultados como números de coma flotante

- If the results should be always printed as floats (`ResultsAsFloats`)

Números de coma flotante en notación científica

- If floats should be in scientific notation (`ScientificNotation`)

Imprimir siempre expresiones completas

- Should we print out full expressions for non-numeric return values (longer than a line) (`FullExpressions`)

Usar fracciones mixtas

- If fractions should be printed as mixed fractions such as "1 1/3" rather than "4/3". (`MixedFractions`)

Mostrar 0.0 cuando el número en coma flotante es menor que 10^-x (0=no truncar nunca)

- How to chop output. But only when other numbers nearby are large. See the documentation of the paramter `OutputChopExponent`.

Sólo truncar los números cuando otro número es mayor que 10^-x

- When to chop output. This is set by the paramter `OutputChopWhenExponent`. See the documentation of the paramter `OutputChopExponent`.

Recordar los ajustes de salida entre sesiones

- Should the output settings in the Number/Expression output options frame be remembered for next session. Does not apply to the Error/Info output options frame.

  If unchecked, either the default or any previously saved settings are used each time Genius starts up. Note that settings are saved at the end of the session, so if you wish to change the defaults check this box, restart Genius Mathematics Tool and then uncheck it again.

Mostrar los errores en una ventana de diálogo

- If set the errors will be displayed in a seprate dialog, if unset the errors will be printed on the console.

Mostrar los mensajes de información en un diálogo

- If set the information messages will be displayed in a seprate dialog, if unset the information messages will be printed on the console.

Máximo de errores que mostrar

- The maximum number of errors to return on one evaluation (`MaxErrors`). If you set this to 0 then all errors are always returned. Usually if some loop causes many errors, then it is unlikely that you will be able to make sense out of more than a few of these, so seeing a long list of errors is usually not helpful.

In addition to these preferences, there are some preferences that can only be changed by setting them in the workspace console. For others that may affect the output see genius-gel-function-parameters.

`IntegerOutputBase`

- La base que se usará para mostrar enteros

`OutputStyle`

- A string, can be `"normal"`, `"latex"`, `"mathml"` or `"troff"` and it will effect how matrices (and perhaps other stuff) is printed, useful for pasting into documents. Normal style is the default human readable printing style of Genius Mathematics Tool. The other styles are for typsetting in LaTeX, MathML (XML), or in Troff.

### Precisión

Precisión en coma flotante

- The floating point precision in bits (`FloatPrecision`). Note that changing this only affects newly computed quantities. Old values stored in variables are obviously still in the old precision and if you want to have them more precise you will have to recompute them. Exceptions to this are the system constants such as `pi` or `e`.

Recordar los ajustes de precisión entre sesiones

- Should the precision setting be remembered for the next session. If unchecked, either the default or any previously saved setting is used each time Genius starts up. Note that settings are saved at the end of the session, so if you wish to change the default check this box, restart genius and then uncheck it again.

### Terminal

«Terminal» se refiere a la consola en el área de trabajo.

Líneas de desplazamiento hacia atrás

- Líneas de desfile hacia atrás en la terminal.

Tipografía

- La tipografía que usar en la terminal.

Negro sobre blanco

- Si usar blanco sobre negro en la terminal.

Cursor parpadeante

- If the cursor in the terminal should blink when the terminal is in focus. This can sometimes be annoying and it generates idle traffic if you are using Genius remotely.

### Memoria

Número máximo de nodos que asignar

- Internally all data is put onto small nodes in memory. This gives a limit on the maximum number of nodes to allocate for computations. This avoids the problem of running out of memory if you do something by mistake which uses too much memory, such as a recursion without end. This could slow your computer and make it hard to even interrupt the program.

  Once the limit is reached, Genius Mathematics Tool asks if you wish to interrupt the computation or if you wish to continue. If you continue, no limit is applied and it will be possible to run your computer out of memory. The limit will be applied again next time you execute a program or an expression on the Console regardless of how you answered the question.

  Establecer el límite a cero significa que no hay límite en la cantidad de memoria que usa Genius.

## Acerca de la herramienta matemática Genius

Genius Mathematics Tool was written by Jiří (George) Lebl (jirka@5z.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.

Para informar de un error o hacer una sugerencia sobre esta aplicación o sobre este manual, siga las explicaciones en este documento.

Este programa se distribuye bajo los términos de la Licencia Pública General GNU (GPL) tal y como fue publicada por la Free Software Foundation, en la versión 2 ó (a su elección) cualquier versión posterior. Una copia de esta licencia puede encontrarse en este enlace, o en el archivo COPYING incluido con el código fuente de este programa.

Jiří Lebl was during various parts of the development partially supported for the work by NSF grant DMS 0900885 and the University of Illinois at Urbana-Champaign. The software has been used for both teaching and research.