Manual de la herramienta matemática Genius.

# Manual de Genius

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

Se concede permiso para copiar, distribuir o modificar este documento según las condiciones de la GNU Free Documentation License (GFDL), Versión 1.1 o cualquier versión posterior publicada por la Free Software Foundation sin Secciones invariantes, Textos de portada y Textos de contraportada. Encontrará una copia de la GFDL en este enlace o en el archivo COPYING-DOCS distribuido con este manual.

Este manual es parte de la colección de manuales GNOME distribuidos bajo la GFDL. Si quiere distribuir este manual separadamente de la colección, puede hacerlo añadiendo una copia de la licencia al manual, tal como se describe en la sección 6 de la licencia.

Muchos de los nombres usados por empresas para distinguir sus productos y servicios se mencionan como marcas comerciales. Donde aparezcan dichos nombres en cualquier documentación GNOME, y para que los miembros del proyecto de documentación reconozcan dichas marcas comerciales, dichos nombres se imprimen en mayúsculas o iniciales mayúsculas.

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

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

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

Jiří
Lebl
Oklahoma State University

     jiri.lebl@gmail.com

Kai
Willadsen
University of Queensland, Australia

     kaiw@itee.uq.edu.au

0.2
October 2021

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

This manual describes version 1.0.27 of Genius.

## Comentarios

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

## Introducción

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

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

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

Generalmente, cuando alguna característica del lenguaje (función, operador, etc...) es nueva en versiones a la 1.0.5 en adelante, se menciona, pero en versiones anteriores a 1.0.5 debería echar un vistazo al archivo NEWS.

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

Línea 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 .

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

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

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. También puede monitorizar las variables del usuario, que es especialmente útil cuando se está ejecutando un cálculo muy largo, o para depurar un cierto programa. Finalmente, la Calculadora permite trazar funciones usando un cuadro de diálogo amigable.

  El menú Ejemplos es una lista de programas de ejemplo o demostraciones. Si abre el menú, cargará el ejemplo en un nuevo programa, que puede ejecutar, editar, modificar y guardar. Estos programas deberían estar bien documentados y generalmente muestran alguna característica de Herramienta matemática Genius o algunos conceptos matemáticos.

  El menú Programas muestra una lista de programas abiertos y le permite cambiar a uno de ellos.

  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. Los programas son un conjunto de comandos o funciones que se pueden ejecutar a la vez sin tener que ejecutarlos desde una terminal. Los programas 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 del área de trabajo. 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á, mostrando su resultado en pantalla.

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

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

or

    genius> 62734 + 812634 + 77^4 mod 5

or

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

or

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

(Last is the harmonic sum from 1 to 70)

To get a list of functions and commands, type:

    genius> help

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

    genius> help FunctionName

To view this manual, type:

    genius> manual

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

    genius> load path/to/program.gel

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

### Crear un programa nuevo

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

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 (o el botón de la barra de herramientas 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 acaba de escribir, elija Archivo Guardar como.... Al igual que en otros programas puede elegir Archivo Guardar para guardar un programa que ya tenía un nombre asignado. Si tiene muchos programas abiertos que ha editado y quiere guardarlos, puede hacerlo eligiendo Archivo Guardar todo.

Los programas que no han guardado los cambios todavía, tienen un símbolo «[+]» junto al nombre de archivo. Así puede ver si el archivo en la pestaña actual y el que está guardado en el disco, difieren en su contenido. Los programas que no se han nombrado todavía, se consideran siempre como no guardados, por lo que no se muestra el símbolo «[+]».

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

Si ha hecho cambios en un archivo y quiere descartarlos y volver a la versión original del disco, puede elegir la opción de menú Archivo Recargar desde el disco. Esto es útil para experimentar con un programa y hacer cambios temporales, ejecutar el programa, pero no hacer que dichos cambios sean permanentes.

## 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 para aprender a introducir expresiones que entienda Genius.

### Trazado de líneas

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

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 .

#### Crear una ventana de dibujo

Shows the line plotting window.

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

Las variables se pueden renombrar al pulsar el botón Cambiar nombres variables..., lo que es útil si quiere imprimir o guardar la figura y no quiere utilizar los nombres predeterminados. Finalmente, puede evitar imprimir la leyenda y las etiquetas de los ejes completamente, lo que también es útil si está imprimiendo o guardando, cuando la leyenda podría ser confusa.

#### Ventana de dibujo

The graph produced.

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 como una función de la variable `t`. El rango de la variable `t` se da explícitamente, y la función se simplifica de acuerdo al incremento dado. El rango `x` e `y` se puede establecer automáticamente activando la casilla Ajustar al eje dependiente o se puede establecer explícitamente. consulte la .

#### Pestaña dibujo paramétrico

Parametric plotting tab in the Create Plot window.

Puede ver un ejemplo de una gráfica de una función paramétrica en la . Puede realizar operaciones similares en esta gráfica, así como en la otras gráficas de funciones lineales. Para dibujar usando la línea de comandos, consulte la documentación de las funciones `LinePlotParametric` o `LinePlotCParametric`.

#### Gráfico paramétrico

Parametric plot produced

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

En la ventana de crear dibujo, también puede elegir la pestaña Campo vectorial para crear un dibujo de campos vectoriales bidimensionales. Con este tipo de gráficos se pueden realizar operaciones similares a las que se hacen con otros gráficos de líneas. Para dibujar usando la línea de comandos, consulte la documentación de la función `VectorfieldPlot`.

De manera predeterminada se muestra la dirección y la magnitud del campo vectorial. Para mostrar únicamente la dirección y no la magnitud, normalice la longitud de las flechas habilitando la opción pertinente.

Cuando un campo vectorial está activo, hay un menú Resolutor adicional disponible a través del cuál puede abrir el diálogo del Resolutor. Aquí encontrará soluciones gráficas específicas de Genius para las condiciones iniciales dadas. Puede especificar condiciones iniciales en el diálogo o pulsar en el dibujo directamente para especificar el punto inicial. Mientras el diálogo del resolutor esté activa, la opción de aumentar el gráfico pulsando y arrastrando no funcionará. Debe cerrar el diálogo primero si quiere aumentar el gráfico con el ratón.

El resolutor usa el método estándar de Runge-Kutta. Los gráficos resultantes permanecerán en la pantalla hasta que se limpie. Aumentar el gráfico no cambia los límites o parámetros de las soluciones, tendrá que limpiar y redibujarlos con los parametros adecuados. También puede usar la función `VectorfieldDrawSolution` para dibujar soluciones desde la línea de comandos o desde programas.

### Gráficos de superficie

Genius también puede dibujar superficies. Seleccione la pestaña Dibujar superficie en el cuaderno de notas principal de la ventana Crear gráfico. Aquí puede especificar una expresión que use o bien `x` e `y` como variables reales independientes o bien `z` como variable compleja (donde `x` sea la parte real de `z` e `y` la parte imaginaria). Por ejemplo, para dibujar los módulos de la función coseno de variable compleja puede escribir `|cos(z)|`. Esto sería equivalente a `|cos(x+1i*y)|`. Consulte la . Para dibujar desde la línea de comandos véase la documentación de la función `SurfacePlot`.

El rango `z` puede establecerse automáticamente al activar el cuadro de selección Ajustar eje dependiente. Las variables se pueden renombrar al pulsar el botón Cambiar nombres variable..., lo que es útil si quiere imprimir o guardar la figura y no quiere utilizar los nombres predeterminados. Finalmente, puede evitar imprimir la leyenda y las etiquetas de los ejes completamente, lo que también es útil si está imprimiendo o guardando, cuando la leyenda podría ser confusa.

#### Gráfico de superficie

Modulus of the complex cosine function.

En el modo de superficie, las teclas izquierda y derecha de su teclado, rotarán la vista a lo largo del eje z. Alternativamente puede rotar en cualquier eje seleccionando Rotar eje... en el menú Ver. El menú Ver también tiene un modo de vista superior que permite rotar el gráfico de modo que el eje z se enfrenta directamente, es decir, vemos el gráfico desde la parte superior y obtenemos los colores que definen los valores de la función obteniendo así un gráfico de temperatura de la función. Finalmente pruebe Iniciar animación de rotación, para iniciar una lenta rotación continua. Esto es especialmente bueno si se utiliza Herramienta matemática Genius para presentar a un público.

## Conceptos de GEL

GEL significa Lenguaje de Extensión de Genius. Éste es el lenguaje que se utiliza para escribir programas para Genius. Un programa en GEL es simplemente una expresión que se evalúa como un número, una matriz, o cualquier objeto en GEL. Por lo tanto, la Herramienta matemática Genius se puede utilizar como una simple calculadora o como una herramienta de investigación teórica muy potente. La sintaxis está pensada para suavizar lo más posible la curva de aprendizaje, especialmente para usarlo como calculadora.

### Valores

Los valores en GEL pueden ser números, booleanos o cadenas. GEL también trata las matrices como valores. 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 of number is floating point. These are entered in a similar fashion to C notation. You can use `E`, `e` or `@` as the exponent delimiter. Note that using the exponent delimiter gives a float even if there is no decimal point in the number. Examples:

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

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

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

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

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

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

    ( (1 + true) - false ) * true

is the same as:

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

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

    1 == true

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

#### 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;"The result is: "+a

will create the string:

    The result is: 5

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

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

will make a string:

    Slash: \ Quotes: " Tabs: 	1	2	3

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

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

    string(22)

will return

    "22"

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

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

Example:

    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

Syntax:

    VariableName

Example:

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

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

Syntax:

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

Example:

    x = 3
    x := 3

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

    a = b = 5

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

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 .

#### Variables integradas

GEL tiene un número de «variables» predeterminadas, tales como `e`, `pi` o `GoldenRatio`. Éstas se usan ampliamente con su valor predeterminado y no se pueden modificar. Existen más variables predeterminadas. Consulte la para obtener la lista completa. Observe que `i` no es el valor predeterminado de la raíz cuadrada de un número negativo (el número imaginario), y es indefinido que permite usarlo como un contador. Si quiere escribir un número imaginario, necesita utilizar `1i`.

#### 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:

    FunctionName(argument1, argument2, ...)

Example:

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

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

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 consultar la 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 that Genius can load in order to make them available. Example:

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

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

#### 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 that are not defined, you can use an anonymous function (see ). That is, you want to pass a function without giving it a name. Syntax:

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

Example:

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

This will return 5.

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

No todas las funciones se pueden usar de este modo. Por ejemplo, cuando usa una función binaria las funciones deben aceptar el mismo número de argumentos.

### Separador

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

    3 ; 5

This expression will yield 5.

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

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

### Comentarios

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

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

### Evaluación modular

Genius implementa aritmética modular. Para usarla, simplemente añada «mod <entero>» después de la expresión. Ejemplo: `2^(5!) * 3^(6!) mod 5` Podría ser posible realizar aritmética modular trabajando con enteros y aplicando el módulo al final con el operador `%`, que simplemente devuelve el resto, pero puede requerir más tiempo o ser imposible cuando se trabaja con valores muy elevados. Por ejemplo `10^(10^10) % 6` puede que no funcione (el exponente es demasiado grande), sin embargo `10^(10^10) mod 6` es instantáneo. La primera expresión primero intenta calcular el entero `10^(10^10)` y luego el resto de la división por 6, mientras que la segunda expresión calcula el módulo 6 de todo primero que nada.

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

    10^-1 mod 101
    1/10 mod 101

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

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

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

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

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

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

No concatene operadores mod, solo colóquelos al final del cálculo, todos los cálculos en la expresión que está a la izquierda se llevarán a cabo bajo aritmética mod. Si coloca un operador mod dentro de un mod seguramente obtendrá resultados inesperados. Si solo quiere aplicar mod a un único número y controlar cuándo se toma el resto, es mejor utilizar el operador `%`. Cuando necesita concatenar varias expresiones en una aritmética modular con diferentes divisores, lo mejor es simplemente dividir la expresión en varias y usar variables temporales para evitar un mod dentro de un mod.

### Lista de operadores GEL

Todo en GEL es en realidad una expresión. Las expresiones se encadenan unas tras otras mediante diferentes operadores. Como hemos visto, incluso el separador es un operador binario en GEL. A continuación se muestra una lista de los operadores en GEL.

`a;b`

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

`a=b`

  El operador asignación. Asigna `b` a `a` (`a` debe ser un lvalue válido) (tenga en cuenta que este operador puede equivaler a `==` si se usa cuando se espera una expresión booleana)

`a:=b`

  El operador asignación. Asigna `b` a `a` (`a` debe ser un lvalue válido). Se diferencia de `=` en que nunca equivale a `==`.

`|a|`

  Valor absoluto. 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.

  Consulte Mathworld para obtener más información.

`a^b`

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

`a.^b`

  Potencia elemento a elemento. Eleva cada elemento de una matriz `a` a la `b`-ésima potencia. O si `b` es una matriz del mismo tamaño que `a`, entonces realiza la operación elemento a elemento. Si `a` es un número y `b` es una matriz entonces crea una matriz del mismo tamaño que `b` formada por `a` elevado a todas las diferentes potencias de `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. Si uno de ellos es una matriz cuadrada y el otro un número, el número se multiplica por la identidad de la matriz.

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

  División. Cuando `a` y `b` son sólo números es la división normal. Cuando son matrices, esto es el equivalente a `a*b^-1`.

`a./b`

  División elemento por elemento. Igual que `a/b` para números, pero opera elemento por elemento en matrices.

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

  El operador mod. No activa el modo modular sino que simplemente devuelve el resto de la división de enteros `a/b`.

`a.%b`

  Operador mod elemento por elemento. Devuelve el resto despues de la división de enteros de elemento por elemento `a./b` .

`a mod b`

  Operación de evaluación modular. La expresión `a` se evalúa módulo `b`. Consulte la . Algunas de las funciones y operadores se comportan de un modo distinto cuando trabajan en módulo entero.

`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` dependiendo de si `a` y `b` son iguales o no.

`a!=b`

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

`a<>b`

  Operador distinto alternativo devuelve `true` si `a` no es igual a `b` en caso contrario devuelve `false`.

`a<=b`

  Operador menor o igual, devuelve `true` si `a` es menor o igual que `b`, si no, devuelve `false`. Esto se puede concatenar como `a <= b <= c` (también se puede combinar con el operador menor que).

`a>=b`

  El operador mayor o igual que, devuelve `true` si `a` es mayor o igual que `b`, si no, devuelve `false`. Esto se puede concatenar como `a >= b >= c` (también se puede combinar con el operador mayor que).

`a<b`

  Operador menor que, devuelve `true` si `a` es menor o igual que `b`, si no, devuelve `false`. Esto se puede concatenar como `a < b < c` (también se puede combinar con el operador menor o igual que).

`a>b`

  Operador mayor que, devuelve `true` si `a` es mayor o igual que `b`, si no, devuelve `false`. Esto se puede concatenar como `a > b > c` (también se puede combinar con el operador mayor o igual que).

`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. Devuelve cierto si `a` y `b` son ciertos; si no, devuelve falso. Si se dan números, los números distintos de cero se consideran como «verdadero».

`a or b`

  OR lógico. Devuelve verdadero si `a` o `b` son verdaderos; si no, devuelve falso. Si se dan números, los números distintos de cero se consideran como verdadero.

`a xor b`

  X-OR lógico. Devuelve cierto si `a` o `b` son ciertos; si no, devuelve falso. Si se dan números, los números distintos de cero se consideran como «verdadero».

`not a`

  NOT lógico. Devuelve la negación lógica de `a`

`-a`

  Operador de negación. Devuelve el negativo de un número o una matriz (en una matriz, funciona de acuerdo al elemento).

`&a`

  Referencia de variables (pasar una referencia a una variable). Consulte .

`*a`

  Desreferenciar una variable (para acceder a una variable referenciada). Consulte la .

`a'`

  Transpuesta conjugada de una matriz. Significa que las filas y columnas se intercambian y se toman la conjugada compleja de todas las entradas. Esto es, si el elemento i,j de `a` es x+iy, entonces el elemento j,i de `a'` es x-iy.

`a.'`

  Transpuesta de matriz, no conjuga las entradas. Esto significa, el elemento i,j de `a` se convierte en el elemento j,i de `a.'`.

`a@(b,c)`

  Devuelve el elemento de una matriz 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 múltiples 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)`

  Obtiene un elemento de una matriz tratándola como vector. Recorre la matriz por filas.

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

  Cuando los números implicados son números en coma flotante, por ejemplo `1.0:0.4:3.0`, la salida es lo que se espera a pesar de la adición de 0,4 a 1,0 cinco veces es en realidad sólo un poco más de 3,0 debido a la forma en que los números de coma flotante se almacenan en la base 2 (no hay 0.4, el número real almacenado es sólo ligeramente más grande). La forma en que se maneja es el mismo que en los bucles «for», «sum», y «prod». Si el final está dentro de `2^-20` veces el tamaño de paso del punto final, se utiliza el punto final y suponemos que no eran errores de redondeo. Esto no es perfecto, pero maneja la mayoría de los casos. Esta comprobación se realiza sólo desde la versión 1.0.18 en adelante, así que la ejecución de su código puede ser diferente en las versiones anteriores. Si quiere evitar este problema, utilice los números racionales reales, posiblemente usando el `float` si quiere obtener los números de punto flotante en el final. Por ejemplo `1:2/5:3` hace lo correcto y `float(1:2/5:3)` incluso le da los números de punto flotante y es ligeramente más precisa que `1,0:0,4:3,0`.

`(a)i`

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

      (a)*1i

``a`

  Escapa un identificador de modo que no sea evaluado. O escapa una matriz de modo que no sea expandida.

`a swapwith b`

  Intercambia el valor de `a` con el valor de `b`. Actualmente no funciona con rangos de elementos matriciales. Devuelve `null`. Está disponible desde la versión 1.0.13.

`increment a`

  Incrementa la variable `a` en 1. Si `a` es una matriz entonces incrementará cada uno de los elementos. Es equivalente a `a=a+1` pero más rápido. Devuelve `null`. Está disponible desde la versión 1.0.13.

`increment a by b`

  Incrementa la variable `a` en `b`. Si `a` es una matriz, entonces incrementa cada elemento. Es equivalente a `a=a+b`, pero más rápido. Devuelve null `null`. Está disponible desde la versión 1.0.13.

El operador @() hace el operador «:» más útil. Con éste puede especificar regiones dentro de una matriz. De modo que a@(2:4,6) representa las filas 2, 3 y 4 de la columna 6. O @(,1:2) devuelve las dos primeras columnas de una matriz. Puede asignar al operador @() siempre que el valor sea una matriz cuyo tamaño coincida con el tamaño de la región asignada o cualquier otro tipo de valor.

Los operadores de comparación (excepto el operador <=> que se comporta de un modo normal), no son estrictamente operadores binarios, de hecho pueden agruparse de una forma matemática estándar, por ejemplo: (1<x<=y<5) es una expresión booleana válida y significa lo que debería, es decir, (1<x and x≤y and y<5)

El operador unario «menos» opera de un modo distinto dependiendo del lugar donde aparece. Si lo hace antes de un número su prioridad es muy alta. Si aparece delante de una expresión tendrá menos prioridad que los operadores potencia y factorial. De este modo, por ejemplo, `-1^k` es en realidad `(-1)^k`, sin embargo `-foo(1)^k` es realmente `-(foo(1)^k)`. Por lo tanto, tenga cuidado con el uso de este operador y si tiene alguna duda, use paréntesis.

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

Examples:

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

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

    if a=5 then a=a-1

will be interpreted as:

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

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

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

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

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

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

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

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

Si no se ejecuta ningún comando (por ejemplo `sum i=1 to 0 do ...`), `sum` devuelve el valor 0 y `prod` devuelve el valor 1, que es el convenio estándar.

Para los números en coma flotante el redondeo de protección de errores se realiza como en el bucle for. Consulte la .

### Operadores de comparación

Los siguientes operadores de comparación comunes están soportados en GEL, y tienen el significado obvio: `==`, `>=`, `<=`, `!=`, `<>`, `<`, `>`. Éstos devuelven los valores `true` o `false`. Los operadores `!=` y `<>` son lo mismo y significan «no es igual a». GEL también permite utilizar el operador `<=>`, que devuelve el valor -1 si el lado izquierdo es menor, 0 si ambos lados son iguales, y 1 si el lado izquierdo es mayor.

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.

No todos los operadores de comparación (salvo el operador `<=>`, que se comporta de manera normal), son operadores binarios en el sentido estricto del concepto. De hecho, se pueden agrupar en el modo matemático usual, por ejemplo: (`1<x<=y<5`) es una expresión booleana legítima que significa lo que debería, es decir (1<x and x≤y and y<5)

Para construir expresiones lógicas utilice las palabras `not`, `and`, `or`, `xor`. Los operadores `or` y `and` son especiales pues evalúan sus argumentos de uno en uno, por lo que la técnica usual para implementar la evaluación condicional también funciona aquí. Por ejemplo, `1 or a=1` no ejecuta el comando `a=1`, pues el primer argumento es verdadero.

### Variables globales y ámbito de variables

GEL es un lenguaje con ámbitos dinámicos. Esto se explicará más adelante. Esto significa que a las variables ordinarias y a las funciones se les asigna un ámbito de manera dinámica. La única excepción son las variables de parámetros, que siempre son globales.

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.

Los argumentos de funciones son exactamente como variables definidas dentro de la función, salvo que éstas se inicializan con el valor que se introduce en la función. Además de esto, se les trata como a cualquier otra variable definida dentro de la función.

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

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

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

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

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

    set(`a,3)

or:

    set("a",3)

La función `set` siempre fija el nivel superior global. No existe alguna manera de definir una variable local en alguna función desde alguna subrutina. Si se necesita hacer esto, debe utilizar ...

Consulte también las funciones `SetElement` y `SetVElement`.

Para recapitular en un lenguaje más técnico: Genius opera con diferentes contextos numerados. El nivel más alto es el contexto 0 (cero). Siempre que se introduce una función , el contexto aumenta, y cuando la función devuelve su resultado el contexto disminuye. Siempre se puede ver una función o una variable desde los contextos mayores. Cuando una variable se define en un contexto menor, al fijar esta variable se crea una nueva variable local en el contexto actual y esta variable sera visible desde los contextos mayores.

También existen variables locales, que sólo pueden ser vistas desde el contexto actual. Cuando se devuelven funciones por un valor se pueden referenciar variables que no son visibles desde un contexto mas alto y esto puede ser problemático. Consulte las secciones Variables locales verdaderas y Devolver funciones.

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

Algunos parámetros están integrados de manera predeterminada y modifican el comportamiento de genius.

### Retorno

Normalmente, una función se compone de una o varias expresiones separadas con punto y coma, y se devuelve el valor de la última expresión. Esto resulta útil en funciones sencillas, pero algunas veces no querrá que una función devuelva el resultado del último cálculo. Podría, por ejemplo, preferir que ésta devolviera algún valor obtenido a la mitad de la función. En este caso, puede utilizar la palabra `return`. La función `return` toma un único valor, que es el valor que se devolverá.

Example:

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

### Referencias

Para algunas funciones puede ser necesario devolver más de un valor. Esto se puede lograr al devolver un vector de valores, pero muchas veces resulta conveniente pasar una referencia a una variable. Puede pasar una referencia a una variable a una función, y la función fijará el valor, eliminando una referencia. Aunque éste es el principal uso de las referencias, no es el único.

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)

La manera como funcionan las referencias y la sintaxis que utilizan son similares al lenguaje C. El operador `&` hace referencia a una variable y `*` la elimina. Ambos pueden aplicarse sólo a un identificador, por lo que `**a` no es una expresión legal en GEL.

References are best explained by an example:

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

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

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

gives us 4.

### Lvalues

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

`a`

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

`*a`

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

`a@(<region>)`

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

Examples:

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

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

## Programación avanzada con GEL

### Control de errores

Si detecta un error en su función, puede salir de ella. Para errores normales, como argumentos del tipo equivocado, puede impedir que se calcule el resultado de la función al agregar la frase `bailout`. Si algo saliera de verdad mal y quisiera interrumpir definitivamente el cálculo en curso, puede utilizar la palabra `exception`.

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

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

### Sintaxis de nivel superior

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

For example,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Es bueno que todas las funciones que toman otras funciones como argumentos utilicen variables locales. De esta manera las funciones que pasan no ven los detalles de la implementación y luego no se confunden.

### Procedimiento de inicio de GEL

Primero, el programa busca el archivo de la biblioteca instalada (la versión compilada `lib.cgel`) en la carpeta instalada; luego, busca en la carpeta actual y finalmente trata de cargar algún archivo no compilado llamado `~/.geniusinit`.

Si alguna vez cambia el lugar donde está instalada la biblioteca, primero deberá compilarla con el comando `genius --compile loader.gel > lib.cgel`

### Cargar programas

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

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

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

    cd directory_with_gel_programs
    ls *.gel

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

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

or

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

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

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

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

and you should get

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

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

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

    [1, 2, 3
     4, 5
     6]

will end up being

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

Cuando las matrices se evalúan y se recorre fila por fila, justo como el operador `M@(j)` que recorre la matriz renglón por renglón.

Tenga cuidado al utilizar «return» en expresiones dentro de corchetes `[ ]`, ya que tiene un significado ligeramente distinto en ese contexto. Comenzará una fila nueva.

### 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].'

Observe que la matriz traspuesta, esto es la que se calcula utilizando el operador `.'`, es más veloz y no crea una copia nueva de la matriz en la memoria. Desafortunadamente, la matriz traspuesta conjugada sí crea una copia nueva. Se recomienda que siempre utilice el operador `.'` cuando trabaje con matrices y vectores reales.

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

Las rutinas de álgebra lineal implementadas en GEL no ofrecen actualmente un paquete numérico bien probado, por lo que no se deberían utilizar para cálculos numéricos críticos. Por otro lado, Genius implementa muy bien muchas operaciones de álgebra lineal con coeficientes racionales y enteros. Éstas son intrínsecamente exactas y, de hecho, dan resultados mucho mejores que las rutinas comunes de doble precisión para álgebra lineal.

Por ejemplo, no tiene sentido calcular el rango y el espacio nulo de una matriz en coma flotante, ya que para todos los fines prácticos, se debe tener en cuenta que la matriz puede tener algunos errores pequeños. Es posible que se obtenga un resultado diferente al esperado. El problema es que con una perturbación pequeña cualquier matriz es de rango completo e invertible. Sin embargo, si la matriz se compone de números racionales, entonces el rango y el espacio nulo serán siempre exactos.

En general, cuando Genius calcula la base de un espacio vectorial determinado (por ejemplo con la función `NullSpace`), se dará la base como una matriz cuyas columnas son los vectores de la base. Es decir, cuando Genius habla de un subespacio lineal se refiere a una matriz cuyo espacio de columna es el subespacio lineal indicado.

Cabe señalar que Genius puede recordar ciertas propiedades de una matriz. Por ejemplo, se recordará si una matriz está en su forma reducida por filas. Si se hacen muchas llamadas a funciones que utilizan internamente la forma reducida por filas de una matriz, se puede reducir por filas la matriz previamente una sola vez. Las llamadas sucesivas a la función `rref` se harán muy rápido.

## Polinomios en GEL

Actualmente, Genius puede manipular polinomios de una variable escritos como vectores y realizar algunas operaciones básicas con ellos. Se prevé ampliar este soporte adicional.

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

También es posible encontrar raíces de los polinomios de grado 1 a 4 mediante el uso de la función `PolynomialRoots`, que llama a la función de la fórmula adecuada. Los polinomios de grado más alto se convertirán en funciones y se resolverán numéricamente al utilizar una función como `FindRootBisection`, `FindRootFalsePosition`, `FindRootMullersMethod`, o `FindRootSecant`.

Consulte la en la lista de funciones el resto de funciones que actúan sobre polinomios.

## Teoría de conjuntos en GEL

Genius incorpora un juego básico de funcionalidades teoréticas. En la actualidad, un conjunto es sólo un vector (o una matriz). Cada objeto distinto se trata como un elemento diferente.

### Usar conjuntos

Al igual que los vectores, los objetos en conjuntos pueden incluir números, cadenas, `null`, matrices y vectores. En un futuro se plantea tener un tipo determinado de conjuntos, en lugar de utilizar vectores. Tenga en cuenta que los números en coma flotante son distintos de los enteros, y que parecen iguales. Esto significa que Genius los tratará como términos distintos, usando las constantes `0` y `0.0`. La constante `null` se trata como un conjunto vacío.

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

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

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

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

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

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

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

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

## Lista de funciones GEL

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

    help FunctionName

### 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, ...)

  Hace una pregunta y presenta una lista de botones para el usuario o un menú de opciones en modo texto). Devuelve el índice en base a 1 de la tecla pulsada. Esto es, devuelve 1 si se presiona la primera tecla, 2 si es la segunda, y así sucesivamente. Si el usuario cierra la ventana (o simplemente entra en modo texto), entonces devuelve la constante `null`. La ejecución del programa permanece bloqueada hasta que el usuario responda.

  Desde la versión 1.0.10 en adelante.

AskString

      AskString (consulta)

      AskString (consulta, predeterminado)

  Hace una pregunta y deja al usuario que introduzca una cadena que luego devuelve. Si el usuario cancela o cierra la ventana, entonces se devuelve la constante `null`. El programa se detiene hasta que el usuario responda. Si de forma predeterminada `default` se da, entonces se escribe de forma automática cada vez que el usuario presiona la tecla «Intro» (desde la versión 1.0.6 en adelante).

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

  Obtener el módulo actual desde fuera del contexto de la función. Esto significa que, si fuera de la función se ejecutó en módulo (utilizando `mod`) entonces esto devuelve lo que este módulo fue. El cuerpo de la función que se llama no se ejecuta en aritmética modular, y esta función interna hace posible hacer funciones GEL que utilizan la aritmética modular.

Identity

      Identity (x)

  Función identidad, devuelve sus argumentos. Esto es equivalente a `function Identity(x)=x`.

IntegerFromBoolean

      IntegerFromBoolean (bval)

  Hacer entero (0 para `false` o 1 para `true`) desde un valor booleano. `bval` también puede ser un número y en el caso de que el valor no sea 0 se interpretará como `true` y si es 0 se interpretará como `false`.

IsBoolean

      IsBoolean (arg)

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

IsDefined

      IsDefined (id)

  Comprobar si un identificador está declarado. Pase una cadena o un identificador. Si pasa una matriz, cada entrada se evaluará por separado y la matriz contendrá cadenas o identificadores.

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)

  Comprobar si el argumento es una referencia a la función. Esto incluye las referencias a variables.

IsMatrix

      IsMatrix (arg)

  Comprobar si el argumento es una matriz. Si bien `null` se considera en algunas ocasiones como una matriz vacía, la función `IsMatrix` no considera a `null` como una matriz.

IsNull

      IsNull (arg)

  Comprobar si el argumento es `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)

  Comprobar pero no evaluar una cadena. Tenga en cuenta que algunos cálculos internos se realizan durante el análisis.

SetFunctionFlags

      SetFunctionFlags (id,opciones...)

  Establece opciones para una función, actualmente `"PropagateMod"` y `"NoModuloArguments"`. Si `"PropagateMod"` se activa, entonces el cuerpo de la función se evalúa en la aritmética modular cuando la función se llama dentro de un bloque que se evaluó con la aritmética modular (se utilizó `mod`). Si se activa `"NoModuloArguments"`, entonces los argumentos de la función se evaluarán con la aritmética modular.

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

CurrentTime

      CurrentTime

  Devuelve la hora UNIX actual con una precisión de microsegundos, como un número en coma flotante. Esto es, devuelve el número de segundos desde el 1 de enero de 1970.

  Desde la versión 1.0.15 en adelante.

display

      display (cadena,expresión)

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

DisplayVariables

      DisplayVariables (var1,var2,...)

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

      DisplayVariables(`x,`y,`z)

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

      DisplayVariables()

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

  Desde la versión 1.0.18 en adelante.

error

      error (cadena)

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

exit

      exit

  Aliases: `quit`

  Sale el programa.

false

      false

  Aliases: `False` `FALSE`

  El valor booleano `false`.

manual

      manual

  Muestra el manual de usuario.

print

      print (cadena)

  Imprime una expresión y luego una nueva línea. El argumento `str` puede ser cualquier expresión. Esto se hace dentro de una cadena antes de imprimir.

printn

      printn (cad)

  Imprime una expresión sin un carácter de nueva línea. El argumento `str` puede ser cualquier expresión. Esto se hace dentro de una cadena antes de imprimir.

PrintTable

      PrintTable (f,v)

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

      PrintTable (f,[0:10])

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

  Desde la versión 1.0.18 en adelante.

protect

      protect (id)

  Puede proteger una variable de ser modificada. Esto se usa en las funciones de GEL internas para evitar que se sobreescriban accidentalmente.

ProtectAll

      ProtectAll ()

  Protege todas la variables actuales definidas, parámetros y funciones desde que se modificaron. Se utiliza por las funciones GEL para impedir accidentalmente que se sobrescriba. Normalmente la herramienta matemática Genius considera desprotegidas las variables que el usuario definió.

  Desde la versión 1.0.7 en adelante.

set

      set (id,val)

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

      set(`x,1)

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

  La función devuelve el `val`, que podrá utilizarse para encadenamiento.

SetElement

      SetElement (id,row,col,val)

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

      SetElement(`x,2,3,1)

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

  Las variables `row` y `col` pueden ser también rangos, y la semántica es la mísma para las configuraciones normales de los elementos con un signo igual.

  La función devuelve el `val`, que podrá utilizarse para encadenamiento.

  Disponible desde la versión 1.0.10 en adelante.

SetVElement

      SetElement (id,elt,val)

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

      SetElement(`x,2,1)

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

  La variable `elt` puede ser un rango, y la semánticas son la mísmas para las configuraciones normales de los elementos con un signo igual.

  La función devuelve el `val`, que podrá utilizarse para encadenamiento.

  Disponible desde la versión 1.0.10 en adelante.

string

      string (s)

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

true

      true

  Aliases: `True` `TRUE`

  El valor booleano `true`.

undefine

      undefine (id)

  Alias: `Undefine`

  Elimina la definición de una variable. Esto incluye variables locales y globales, cada valor se limpia en toda su dimensión. Esta función no se usa en variables locales. Se puede usar un vector de identificadores para eliminar la definición de varias variables a la vez.

UndefineAll

      UndefineAll ()

  Elimina la definición de todas las variables desprotegidas globales (incluyendo funciones y parámetros). La herramienta matemática Genius considera a las variables protegidas como variables y funciones definidas por el sistema. Tenga en cuenta que `UndefineAll` solo elimina la definición global de símbolos no locales, por lo que se puede ejecutar desde dentro de otras funciones de manera segura.

  Desde la versión 1.0.7 en adelante.

unprotect

      unprotect (id)

  Desproteger una variable de ser modificada.

UserVariables

      UserVariables ()

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

  Desde la versión 1.0.7 en adelante.

wait

      wait (secs)

  Esperar un número específico de segundos. `secs` no puede ser negativo. Cero es aceptable y no pasa nada en este caso, excepto si los posibles eventos de interfaz del usuario se procesan.

  Desde la versión 1.0.18, la variable `secs` puede ser un número no entero, así `wait(0.1)` esperará durante un periodo de una décima de segundo.

version

      version

  Devuelve la versión de Genius como un vector horizontal de tres argumentos en el que el primero es la versión mayor, le sigue menor versión y la revisión en último lugar.

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 función `GaussDistribution`.

IntegerOutputBase

      IntegerOutputBase = número

  Base de salida de enteros.

IsPrimeMillerRabinReps

      IsPrimeMillerRabinReps = número

  Número de tests de Miller-Rabin adicionales que ejecutar sobre un número antes de declararlo primo en `IsPrime`.

LinePlotDrawLegends

      LinePlotDrawLegends = true

  Le dice a Genius cómo dibujar las leyendas para las funciones para dibujar líneas tales como `LinePlot`.

LinePlotDrawAxisLabels

      LinePlotDrawAxisLabels = true

  Le dice a Genius que dibuje las etiquetas de los ejes cuando se utilizan funciones para dibujar líneas como `LinePlot`.

  Desde la versión 1.0.16 en adelante.

LinePlotVariableNames

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

  Le dice a Genius qué nombres de variable se usan como nombres predeterminados para funciones para dibujar líneas tales como `LinePlot` y compañía.

  Desde la versión 1.0.10 en adelante.

LinePlotWindow

      LinePlotWindow = [x1,x2,y1,y2]

  Establece los límites para lasfunciones para dibujar líneas tales como `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

  Cuando otro número que se imprime en el objeto (una matriz o un valor) es mayor que 10-OutputChopWhenExponent, y el número que se imprime es menor que 10-OutputChopExponent, entonces se mostrará `0.0` en lugar del número.

  La salida nunca se corta si `OutputChopExponent` es cero. El número será un entero positivo.

  Si quiere que la salida siempre se corte según `OutputChopExponent`, configure `OutputChopWhenExponent`, para un valor mayor o igual a `OutputChopExponent`.

OutputChopWhenExponent

      OutputChopWhenExponent = número

  Cuando recortar la salida. Consulte `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]

  Establece el número de pasos verticales y horizontales en un diagrama de pendientes. (Consulte `SlopefieldPlot`).

  Desde la versión 1.0.10 en adelante.

SumProductNumberOfTries

      SumProductNumberOfTries = número

  Cuántas iteraciones probar para `InfiniteSum` y `InfiniteProduct`.

SumProductSFS

      SumProductSFS = número

  La cantidad de pasos consecutivos para estar dentro de los límites para `InfiniteSum` y `InfiniteProduct`.

SumProductTolerance

      SumProductTolerance = número

  Tolerancia para `InfiniteSum` y `InfiniteProduct`.

SurfacePlotDrawLegends

      SurfacePlotDrawLegends = true

  Le dice a Genius cómo dibujar las leyendas para las funciones de dibujado de superficie tales como `SurfacePlot`.

  Desde la versión 1.0.16 en adelante.

SurfacePlotVariableNames

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

  Indica a Genius los nombres de variables que se usan como nombres predeterminados para las funciones de superficie de dibujado que utiliza `SurfacePlot`. Compruebe que `z` no se refiere al eje dependiente (vertical), sino que a la variable compleja independiente `z=x+iy`.

  Desde la versión 1.0.10 en adelante.

SurfacePlotWindow

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

  Establece los límites de la superficie de dibujado (consulte `SurfacePlot`).

VectorfieldNormalized

      VectorfieldNormalized = true

  Indica si la longitud de las flechas tendrá un tamaño normalizado en el trazado dentro del campo vectorial. Si es cierto, en el campo vectorial solo aparecerá la dirección y no la magnitud. (Consulte `VectorfieldPlot`).

VectorfieldTicks

      VectorfieldTicks = [vertical,horizontal]

  Establece el número de pasos verticales y horizontales en un gráfico de campo de vectores. (Observe `VectorfieldPlot`).

  Desde la versión 1.0.10 en adelante.

### Constantes

CatalanConstant

      CatalanConstant

  Constante de Catalan, aproximadamente 0,915... Se define para las series donde los términos son `(-1^k)/((2*k+1)^2)`, donde `k` tiene un rango desde 0 a infinito.

  Consulte la Wikipedia o la enciclopedia matemática 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.

Gravity

      Gravedad

  La aceleración en caída libre al nivel del mar en metros por segundos al cuadrado. Es la constante de gravedad estandarizada y su valor es 9.80665. La gravedad en un desfiladero de un bosque es diferente debido principalmente a la diferencia de altitud y al hecho de que la Tierra no es perfectamente redonda ni uniforme.

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

e

      e

  La base del logaritmo natural. `e^x` es la función exponencial `exp`. Su valor es aproximadamente 2.71828182846... Este número se llama número de Euler, aúnque hay varios números que se llaman también Euler. Un ejemplo es la constante gamma: `Constante de Euler`.

  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`

  Valor absoluto de un número y, si `x` es un valor complejo, el módulo de `x`. Es decir, es la distancia entre `x` y el origen. Esto es equivalente a `|x|`.

  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)

  Aliases: `conj` `Conj`

  Calcula el conjugado complejo del número complejo `z`. Si `z` es un vector o una matriz, se conjugan todos sus elementos.

  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. Por ejemplo `Re(3+4i)` yields 4.

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

IntegerQuotient

      IntegerQuotient (m,n)

  División sin resto.

IsComplex

      IsComplex (num)

  Comprueba si el argumento es un número complejo (no real). Observe que hacemos énfasis en número no real. Es decir, `IsComplex(3)` que devuelve «false», mientras que `IsComplex(3-1i)` devuelve «true».

IsComplexRational

      IsComplexRational (num)

  Comprobar si el argumento es, posiblemente, un número racional complejo. Esto es, si tanto la parte real como la imaginaria se dan como números racionales. Por supuesto, racional significa simplemente que «no se almacena como un número en coma flotante».

IsFloat

      IsFloat (num)

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

IsGaussInteger

      IsGaussInteger (num)

  Alias: `IsComplexInteger`

  Comprueba si un argumento es un posible número entero complejo. Es decir, un entero complejo es un número de la forma `n+1i*m` donde `n` y `m` son enteros.

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. Esto es, cualquier número entero positivo o cero.

IsPositiveInteger

      IsPositiveInteger (num)

  Alias: `IsNaturalNumber`

  Comprueba si el argumento es un entero real positivo. Tenga en cuenta que se acepta el convenio de que 0 no es un número natural.

IsRational

      IsRational (num)

  Comprobar si el argumento es un número racional (no complejo). Por supuesto, racional significa «no almacenado como un número en coma flotante».

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`

  Obtiene la parte real de un número complejo. Por ejemplo `Re(3+4i)` devuelve 3.

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

Sign

      Sign (x)

  Alias: `sign`

  Devolver el signo de un número. Devuelve `-1` si es negativo, `0` si es cero y `1` si es positivo. Si `x` es un valor complejo `Sign` devuelve su dirección o 0.

ceil

      ceil (x)

  Alias: `Ceiling`

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

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

  Tenga en cuenta que los números en coma flotante se almacenan en binario y que puede que el resultado no sea lo que espera. Por ejemplo `ceil(420/4.2)` devuelve 101 en vez de 100. Esto sucede porque en realidad 4,2 es ligeramente menor que 4,2. Utilice la representación racional `42/10` si quiere exactitud aritmética.

exp

      exp (x)

  La función exponencial. Esto es la función `e^x` donde `e` es la base del logaritmo natural.

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

float

      float (x)

  Convertir un número en un valor en coma flotante. Esto devuelve la representación en coma flotante del número `x`.

floor

      floor (x)

  Alias: `Floor`

  Obtener el entero más alto menor o igual que `n`.

ln

      ln (x)

  El logaritmo natural, logaritmo en base `e`.

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

log

      log (x)

      log (x,b)

  Logaritmo de `x` en base `b` (se llama `DiscreteLog` en modo módulo), si no se indica la base, se utiliza `e`.

log10

      log10 (x)

  Logaritmo de `x` en base 10.

log2

      log2 (x)

  Alias: `lg`

  Logaritmo de `x` en base 2.

max

      max (a,args...)

  Aliases: `Max` `Maximum`

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

min

      min (a,args...)

  Aliases: `Min` `Minimum`

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

rand

      rand (tamaño...)

  Generar valores en coma flotante aleatorios en el rango `[0,1)`. Si se indica «tamaño», entonces devuelve una matriz (si se especifican dos números) o un vector (si se especifica un número).

randint

      randint (máx,tamaño...)

  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 la Wikipedia o Planetmath para obtener más información.

trunc

      trunc (x)

  Aliases: `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 than failing.

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

cos

      cos (x)

  Calcula la función coseno.

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

cosh

      cosh (x)

  Calcula la función coseno hiperbólico.

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

cot

      cot (x)

  La función cotangente.

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

coth

      coth (x)

  La función cotangente hiperbólica.

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

csc

      csc (x)

  La función cosecante.

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

csch

      csch (x)

  La función cosecante hiperbólica.

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

sec

      sec (x)

  La función secante.

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

sech

      sech (x)

  La función secante hiperbólica.

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

sin

      sin (x)

  Calcula la función seno.

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

sinh

      sinh (x)

  Calcula la función seno hiperbólico.

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

tan

      tan (x)

  Calcula la función tangente.

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

tanh

      tanh (x)

  La función tangente hiperbólica.

  Consulte la Wikipedia o 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 la Wikipedia o 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`

  Encontrar la `x` que resuelve el sistema dado por el vector `a` y el módulo de los elementos de `m`, utilizando el «teorema chino del resto».

  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)

  Convertir un número en un vector de potencias para elementos en base `b`.

DiscreteLog

      DiscreteLog (n,b,q)

  Encontrar el logaritmo discreto de `n` en base `b` en Fq, el campo finito de orden `q`, donde `q` es primo, utilizando el algoritmo de Silver-Pohlig-Hellman.

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

Divides

      Divides (m,n)

  Comprueba la divisibilidad (si `m` divide a `n`).

EulerPhi

      EulerPhi (n)

  Calcular la función phi de Euler para `n`, que es el número de enteros entre 1 y `n` primo relativo con `n`.

  Consulte la Wikipedia, 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 it is only useful if you know that the division is exact.

Factorize

      Factorize (n)

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

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

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

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

FermatFactorization

      FermatFactorization (n,tries)

  Probar la factorización de Fermat de `n` en `(t-s)*(t+s)`, devuelve `t` y `s` como un vector si es posible, `null` de otra manera `tries` especifica el número de intentos antes de abandonar

  Es una buena factorización si su número es el producto de dos factores que están muy cerca.

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

FindPrimitiveElementMod

      FindPrimitiveElementMod (q)

  Encontrar el primer elemento primitivo en Fq, en el grupo de orden finito`q`. Por supuesto, `q` debe de ser primo.

FindRandomPrimitiveElementMod

      FindRandomPrimitiveElementMod (q)

  Encontrar un elemento primitivo aleatorio en Fq, en el grupo de orden finito `q` (q debe de ser primo)

IndexCalculus

      IndexCalculus (n,b,q,S)

  Calcula la base del logaritmo discreto `b` de n en Fq, el grupo finito de orden `q` (`q` un primo), utilizando el factor base `S`. `S` será una columna de números primos y una segunda columna precalculada por `IndexCalculusPrecalculation`.

IndexCalculusPrecalculation

      IndexCalculusPrecalculation (b,q,S)

  Ejecuta los pasos para los cálculos previos de `IndexCalculus` para logaritmos de base `b` en Fq, del grupo finito de orden `q` (`q` un primo), para el factor base `S` (donde `S` es una columna de vector de primos). Los registros se calculan previamente y se devuelven en la segunda columna.

IsEven

      IsEven (n)

  Comprueba si un entero es par.

IsMersennePrimeExponent

      IsMersennePrimeExponent (p)

  Comprueba si un entero positivo `p` es un exponente primo de Mersenne. Esto es si 2p-1 es un primo. Esto lo hace mirando en una tabla de valores conocidos que es relativamente corta. Vea también MersennePrimeExponents y LucasLehmer.

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

IsNthPower

      IsNthPower (m,n)

  Comprueba si un número racional `m` es una potencia `n`-ésima perfecta. Consulte IsPerfectPower y IsPerfectSquare.

IsOdd

      IsOdd (n)

  Comprueba su un entero es impar.

IsPerfectPower

      IsPerfectPower (n)

  Comprobar si un entero es una potencia perfecta, ab.

IsPerfectSquare

      IsPerfectSquare (n)

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

IsPrime

      IsPrime (n)

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

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

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

IsPrimitiveMod

      IsPrimitiveMod (g,q)

  Comprobar si `g` es primario en Fq, el grupo finito de orden `q`, donde `q` es un primo. Si `q` no es un primo los resultados son falsos.

IsPrimitiveModWithPrimeFactors

      IsPrimitiveModWithPrimeFactors (g,q,f)

  Comprobar si `g` es primario en Fq, el grupo finito de orden `q`, donde `q` es un primo y `f` es un vector de factores primos de `q`-1. Si `q` no es primo los resultados son falsos.

IsPseudoprime

      IsPseudoprime (n,b)

  Si `n` es pseudo-primo en base `b` pero no un primo, esto es si `b^(n-1) == 1 mod n`. Esto llama a `PseudoprimeTest`

IsStrongPseudoprime

      IsStrongPseudoprime (n,b)

  Compruebe si `n` es un pseudo-primo fuerte en base `b` pero no un primo.

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)

  Devuelve el resto de `a` mod `n` con el último valor absoluto (en el intervalo -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)

  Compruebe si 2p-1 es un primo de Mersenne utilizando la prueba de Lucas-Lehmer. Consulte también MersennePrimeExponents y IsMersennePrimeExponent.

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

LucasNumber

      LucasNumber (n)

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

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

MaximalPrimePowerFactors

      MaximalPrimePowerFactors (n)

  Devuelve todos los factores primos de un número.

MersennePrimeExponents

      MersennePrimeExponents

  Un vector de Mersenne de exponentes primos conocidos, esto es una lista de enteros positivos `p` tal que 2p-1 es un primo. Consulte también IsMersennePrimeExponent y LucasLehmer.

  Consulte la Wikipedia, Planetmath, Mathworld o GIMPS para 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)

  Utiliza la prueba Miller-Rabin de números primos de `n` con las bases suficientes que asuman la hipótesis generalizada de Reimann, el resultado es determinista.

  Consulte la Wikipedia, 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)

  Devuelve la función de Moebius «mu» de `n`. Esto es, devuelve 0 si `n` no es un producto entre primos distintos y `(-1)^k` si es un producto de `k` primos distintos.

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

NextPrime

      NextPrime (n)

  Devuelve el primo menor más grande que `n`. Los primos negativos se consideran primos y así para obtener el primo anterior, puede usar `-NextPrime(-n)`.

  Esta función utiliza las GMP `mpz_nextprime` la cual vuelve a utilizar la prueba probabilística de Miller-Rabin (consulte también `MillerRabinTest`). La probabilidad de un falso positivo no se da, pero es lo suficientemente baja para prácticamente todos los propósitos.

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

PadicValuation

      PadicValuation (n,p)

  Devuelve la evaluación del número «p-adic» (número de ceros que va dejando en base `p`).

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

PowerMod

      PowerMod (a,b,m)

  Calcula `a^b mod m`. La potencia `b` de `a` módulo `m`. No es necesario utilizar esta función ya que se utiliza automáticamente en modo módulo. Por lo tanto `a^b mod m` es igual de rápido.

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 la Wikipedia o 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)

  Elimina todas las instancias del factor `m` desde el número `n`. Esto es, lo divide por la potencia mas grande de `m`, que divide `n`.

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

SilverPohligHellmanWithFactorization

      SilverPohligHellmanWithFactorization (n,b,q,f)

  Buscar el logaritmo sencillo de `n` base `b` en Fq, de grupo de orden finito `q`, donde `q` es un primo que utiliza el algoritmo de Silver-Pohlig-Hellman, dado `f` es la factorización de `q`-1.

SqrtModPrime

      SqrtModPrime (n,p)

  Buscar la raíz cuadrada de `n` módulo `p` (donde `p` es un primo). Se devuelve «null» si el resto no es cuadrático.

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

StrongPseudoprimeTest

      StrongPseudoprimeTest (n,b)

  Ejecutar la prueba del pseudo-primo fuerte en base `b` de `n`.

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

gcd

      gcd (a,args...)

  Alias: `GCD`

  Máximo común divisor de enteros. Puede introducir tantos enteros en la lista de argumentos, o puede introducir un vector o una matriz de enteros. Si introduce más de una matriz del mismo tamaño, entonces el máximo común divisor se realiza elemento a elemento.

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

lcm

      lcm (a,args...)

  Alias: `LCM`

  Mínimo común múltiplo de enteros. Puede introducir tantos enteros en la lista de argumentos, o introducir un vector o matriz de enteros. Si introduce mas de una matriz del mismo tamaño, entonces el mínimo común múltiplo se realiza elemento a elemento.

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

### Manipulación de matrices

AppendElement

      AppendElement (v,elt)

  Añadir un elemento a un vector y devolver el vector. No se realiza la expansión. Normalmente un vector de fila se construye empezando por `null` o por una matriz de 1x1, pero si se da un vector columna construirá correctamente un vector de este tipo.

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)

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

  Contar el número de cero columnas en una matriz. Por ejemplo una vez que su columna reduce una matriz puede usar esto para encontrar la nulidad. Consulte `cref` y `Nullity`.

DeleteColumn

      DeleteColumn (M,col)

  Eliminar una columna de una matriz.

DeleteRow

      DeleteRow (M,row)

  Eliminar una fila de una matriz.

DiagonalOf

      DiagonalOf (M)

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

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

DotProduct

      DotProduct (u,v)

  Obtener el producto escalar de dos vectores. Los vectores serán del mismo tamaño. Se toman no conjugados por lo que tendrá forma bilineal incluso si se trabaja con números complejos. Esto es el producto escalar bilineal, no el producto escalar sesquilienal. Consulte HermitianProduct para el producto interno estándar sesquilinear.

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

ExpandMatrix

      ExpandMatrix (M)

  Expandir una matriz de la misma manera que hacemos con la entrada sin comillas de la matriz. Esto es, se expande cualquier matriz interna como bloques. Esto es una manera de construir matrices fuera de las mas pequeñas y se hace de manera automática en la entrada a menos que la matriz se entrecomille.

HermitianProduct

      HermitianProduct (u,v)

  Alias: `InnerProduct`

  Obtener el producto de Hermitian de dos vectores. Los vectores serán del mismo tamaño. Esto es una forma «sesquilinear» para utilizar la identidad de la matriz.

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

I

      I (n)

  Alias: `eye`

  Devolver una matriz identidad del tamaño dado, es decir, de `n` por `n`. Si `n` es cero, devuelve `null`.

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

IndexComplement

      IndexComplement (vec,msize)

  Devuelve el complemento índice de un vector de índices. Todo en base a uno. Por ejemplo para el vector `[2,3]` y tamaño `5`, devolverá `[1,4,5]`. Si `msize` es 0, siempre devolverá `null`.

IsDiagonal

      IsDiagonal (M)

  Es una matriz diagonal.

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

IsIdentity

      IsIdentity (x)

  Comprobar si una matriz es la matriz de identidad. Automáticamente devuelve `false` si la matriz no es cuadrada. También trabaja con números, en cualquier caso este es equivalente a `x==1`. Cuando `x` es `null` (imaginemos que es como una matriz de 0 por 0), no se genera error y se devuelve `false`.

IsLowerTriangular

      IsLowerTriangular (M)

  Es una matriz triangular inferior. Esto es, todas las entradas están por encima de la diagonal cero.

IsMatrixInteger

      IsMatrixInteger (M)

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

IsMatrixNonnegative

      IsMatrixNonnegative (M)

  Comprobar si una matriz no es negativa, es decir, si cada elemento no es negativo. No confunda matrices positivas con matrices semidefinidas positivas.

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

IsMatrixPositive

      IsMatrixPositive (M)

  Comprobar si una matriz es positiva, es decir, si cada elemento es positivo (y por lo tanto real). Individualmente, ningún elemento es 0. No confunda matrices positivas con matrices definidas positivas.

  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)

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

IsMatrixSquare

      IsMatrixSquare (M)

  Comprobar si una matriz es cuadrada, es decir, si su altura es igual a su anchura.

IsUpperTriangular

      IsUpperTriangular (M)

  ¿Es una matriz triangular superior?. Esto se cumple si todas las entradas por debajo de la diagonal son cero.

IsValueOnly

      IsValueOnly (M)

  Comprobar si una matriz es una matriz de sólo números. Muchas funciones internas hacen esta comprobación. Los valores pueden ser cualquier número, incluyendo números complejos.

IsVector

      IsVector (v)

  Indica si el argumento de un vector es horizontal o vertical. Genius no distingue entre una matriz y un vector, y un vector es justo una matriz 1 por `n` o `n` por 1.

IsZero

      IsZero (x)

  Comprobar si una matriz está compuesta toda por ceros. También trabaja con números, en cualquier caso esto es equivalente a `x==0`. Cuando `x` es `null` (imagine que es una matriz de 0 por 0), no se genera ningún error y devuelve `true` que indica que la matriz está compuesta de ceros.

LowerTriangular

      LowerTriangular (M)

  Devuelve una copia de la matriz `M` con todas las entradas por encima de la diagonal establecidas a cero.

MakeDiagonal

      MakeDiagonal (v,arg...)

  Alias: `diag`

  Hacer una matriz diagonal desde un vector. Alternativamente puede pasarle los valores como argumentos para la diagonal. Así `MakeDiagonal([1,2,3])` es lo mismo que `MakeDiagonal(1,2,3)`.

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

MakeVector

      MakeVector (A)

  Alias: `MakeColumnVector`

  Hacer un vector columna fuera de la matriz colocando columnas una encima de la otra. Devuelve `null` cuando se introduce `null`. Se puede usar para asegurarse de que un vector es un vector columna.

MakeRowVector

      MakeRowVector (A)

  Hacer un vector fila fuera de la matriz colocando columnas una después de la otra. Devuelve `null` cuando se introduce `null`. Se puede usar para asegurarse de que un vector es un vector fila.

MatrixProduct

      MatrixProduct (A)

  Calcular el producto de todos los elementos en una matriz o vector. Es decir, multiplicar todos los elementos y devolver un número que es el producto de todos los elementos.

MatrixSum

      MatrixSum (A)

  Calcular la suma de todos los elementos en una matriz o vector. Es decir, sumar todos los elementos y devolver un número que es el resultado de la suma de todos los elementos.

MatrixSumSquares

      MatrixSumSquares (A)

  Calcular la suma de los cuadrados de todos los elementos en una matriz o vector.

NonzeroColumns

      NonzeroColumns (M)

  Devuelve una fila vector de índices de columnas distintas de cero en la matriz `M`.

  Desde la versión 1.0.18 en adelante.

NonzeroElements

      NonzeroElements (v)

  Devuelve una fila vector de índices de elementos distintos de cero en el vector `v`.

  Desde la versión 1.0.18 en adelante.

OuterProduct

      OuterProduct (u,v)

  Obtener el producto externo de dos vectores. Esto es, suponga que `u` y `v` son vectores verticales, entonces el producto externo es `v * u.'`.

ReverseVector

      ReverseVector (v)

  Invierte el orden de los elementos de un vector (devuelve `null` si se le pasa `null`).

RowSum

      RowSum (m)

  Calcula la suma de cada fila de una matriz y devuelve el resultado en un vector vertical con el resultado

RowSumSquares

      RowSumSquares (m)

  Calcular la suma de los cuadrados de cada fila de una matriz y devolver una matriz columna con los resultados.

RowsOf

      RowsOf (M)

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

SetMatrixSize

      SetMatrixSize (M,filas,columnas)

  Hacer una nueva matriz del mismo tamaño que otra. Es decir, devolverá una nueva matriz con la copia de otra. Las entradas que no caben, se recortan y el espacio adicional se rellena con ceros. Si `rows` o `columns` son cero, entonces se devuelve`null`.

ShuffleVector

      ShuffleVector (v)

  Mezcla los elementos en un vector. Devuelve `null` si se le pasa `null`.

  Desde la versión 1.0.13 en adelante.

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)

  Devolver columnas y filas desde una matriz. Esto es equivalente a `m@(r,c)`. `r` y `c` serán vectores de filas y columnas (o números sencillos si sólo se necesita una fila o columna).

SwapRows

      SwapRows (m,fila1,fila2)

  Intercambiar dos columnas de una matriz.

UpperTriangular

      UpperTriangular (M)

  Devuelve una copia de la matriz `M` con todas las entradas por debajo de la diagonal establecidas a cero.

columns

      columns (M)

  Obtener el número de columnas de una matriz.

elements

      elements (M)

  Obtener el número total de elementos de una matriz. Es decir, el número de columnas por el número de filas.

ones

      ones (filas,columnas...)

  Hacer una matriz rellena de unos (o un vector fila si sólo se introduce un argumento). Devuelve `null` si cualquier fila o columna es cero.

rows

      rows (M)

  Obtener el número de filas de una matriz.

zeros

      zeros (filas,columnas...)

  Hacer una matriz llena de ceros (o un vector fila si se introduce sólo un argumento). Devuelve `null` si cualquier fila o columna es cero.

### Álgebra lineal

AuxiliaryUnitMatrix

      AuxiliaryUnitMatrix (n)

  Obtener la matriz auxiliar de tamaño `n`. Esto es una matriz cuadrada que es toda ceros excepto la superdiagonal, que son todos unos. Es la matriz de bloques de Jordan de un cero como valor propio.

  Consulte Planetmath o Mathworld para obtener más información sobre la forma canónica de Jordan.

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`

  Obtener el polinomio característico como un vector. Es decir, devuelve los coeficientes del polinomio empezando por el término constante. Este polinomio se define por `det(M-xI)`. Las raíces de este polinomio tienen como valor propio a `M`. Consulte CharacteristicPolynomialFunction.

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

CharacteristicPolynomialFunction

      CharacteristicPolynomialFunction (M)

  Obtener el polinomio característico como una función. Es decir, el polinomio se define por `det(M-xI)`. Las raíces de este polinomio tienen un valor propio de `M`. Consulte CharacteristicPolynomial.

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

ColumnSpace

      ColumnSpace (M)

  Obtener una matriz base para el espacio de la columna de una matriz. Es decir, devuelve una matriz la cual las columnas son las bases para el espacio de la columna `M`. Esto es el espacio generado por las columnas de `M`.

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

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)

  Conjugada traspuesta de una matriz (adjunta). Es lo mismo que el operador `'`.

  Consulte la Wikipedia o 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)

  Calcular la convolución de dos vectores horizontales. Devuelve el resultado como un vector y no se suman.

CrossProduct

      CrossProduct (v,w)

  Producto cruzado de dos vectores en R3 como un vector columna.

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

DeterminantalDivisorsInteger

      DeterminantalDivisorsInteger (M)

  Obtiene determinantes divisores de una matriz de enteros.

DirectSum

      DirectSum (M,N...)

  Suma directa de matrices.

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

DirectSumMatrixVector

      DirectSumMatrixVector (v)

  Suma directa de un vector de matrices.

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

Eigenvalues

      Eigenvalues (M)

  Alias: `eig`

  Obtener los valores propios de una matriz cuadrada. En la actualidad solo funciona con matrices de tamaño 4 por 4 como máximo, o para matrices triangulares (cuyo valores propios están en la diagonal).

  Consulte la Wikipedia, 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, Planetmath, o Mathworld para obtener más información.

GramSchmidt

      GramSchmidt (v,B...)

  Aplicar el proceso de Gram-Schmidt (a las columnas) con respecto al propio producto dado por `B`. Si `B` no se da, entonces se utiliza el producto Hermitiano estándar. `B` también puede ser una función sesquilineal de dos argumentos o puede ser una matriz que devuelve una forma sesquilineal. Los vectores serán ortonormales con respecto a `B`.

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

HankelMatrix

      HankelMatrix (c,r)

  La matriz de Hankel es una matriz cuyas diagonales (de izquierda a derecha) son constantes. La primera fila es `c` y la última colúmna es `r`. Se considera que ambos argumentos son vectores y que el último elemento de la fila `c` es el mismo que el primer elemento de la columna `r`.

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

HilbertMatrix

      HilbertMatrix (n)

  Matriz de Hilbert de orden `n`.

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

Image

      Image (T)

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

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

InfNorm

      InfNorm (v)

  Obtener el operador norma de un vector, a veces también se denomina norma suprema o norma máxima.

InvariantFactorsInteger

      InvariantFactorsInteger (M)

  Obtiene los factores invariantes de una matriz cuadrada de enteros.

InverseHilbertMatrix

      InverseHilbertMatrix (n)

  Matriz inversa de Hilbert de orden `n`.

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

IsHermitian

      IsHermitian (M)

  Es una matriz Hermitian. Es decir, es igual a su traspuesta conjugada.

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

IsInSubspace

      IsInSubspace (v,W)

  Comprueba si un vector está en un subespacio.

IsInvertible

      IsInvertible (n)

  Es una matriz (o número) invertible (La matriz de enteros es invertible si, y sólo si esta es invertible sobre los enteros).

IsInvertibleField

      IsInvertibleField (n)

  Es una matriz (o un número) inversible sobre un campo.

IsNormal

      IsNormal (M)

  Indica que `M` es una matriz normal. Es decir, realiza `M*M' == M'*M`.

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

IsPositiveDefinite

      IsPositiveDefinite (M)

  Indica que `M` es una matriz definida positiva Hermitiana. Esto es si `HermitianProduct(M*v,v)` es siempre estrictamente positivo para cualquier vector `v`. `M` será cuadrada y Hermitiana para ser definida positiva. La comprobación de que se lleva a cabo es que cada submatriz principal tiene un determinante no negativo. (Consulte HermitianProduct)

  Tenga en cuenta que algunos autores (por ejemplo Mathworld) no requieren que `M` sea Hermitiana, y entonces la condición está en la parte real del propio producto, pero aquí no se compartirá este punto de vista. Si quiere comprobarlo, hacer sólo la parte Hermitiana de la matriz `M` como sigue: `IsPositiveDefinite(M+M')`.

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

IsPositiveSemidefinite

      IsPositiveSemidefinite (M)

  Indica si `M` es una matriz semidefinida positiva Hermitiana. Esto es si `HermitianProduct(M*v,v)` es siempre no negativo para cualquier vector `v`. `M` será cuadrada y Hermitiana para ser semidefinida positiva. La comprobación que se lleva a cabo es que cada submatriz principal tenga un determinante no negativo. (Consulte HermitianProduct)

  Tenga en cuenta que algunos autores no requieren que `M` sea Hermitiana, y entonces la condición está en la parte real del propio producto, pero aquí no se compartirá este punto de vista. Si quiere comprobarlo, hacer sólo la parte Hermitiana de la matriz `M` como sigue: `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)

  ¿Es una matriz unitaria?. Esto es, hacer `M'*M` y `M*M'` igual a la identidad.

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

JordanBlock

      JordanBlock (n,lambda)

  Alias: `J`

  Obtener el bloque de Jordan correspondiente al valor propio `lambda` con multiplicidad `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.

  (Consulte NullSpace)

KroneckerProduct

      KroneckerProduct (M, N)

  Alias: `TensorProduct`

  Calcula el producto de Kronecker (producto tensorial en base estándar) de dos matrices.

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

  Desde la versión 1.0.18 en adelante.

LUDecomposition

      LUDecomposition (A, L, U)

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

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

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

  Esto es la descomposición de LU de una matriz también conocido como Crout y/o reducción de Cholesky. (ISBN 0-201-11577-8 pp.99-103) La matriz triangular superior cuenta con una diagonal de valores 1 (uno). Esto no es el método de Doolittle en las que los unos de la diagonal están sobre la matriz inferior.

  No todas las matrices tienen la descomposición de LU, por ejemplo `[0,1;1,0]` no lo hace y esta función devuelve `false` en este caso, y establece `L` y `U` a `null`.

  Consulte la Wikipedia, 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)

  Devolver las columnas que no son las columnas pivotes de una matriz.

Norm

      Norm (v,p...)

  Alias: `norm`

  Obtener la norma p (o 2 normas si no se suministra p) de un vector.

NullSpace

      NullSpace (T)

  Obtener el espacio nulo de una matriz. Ese es el núcleo de la aplicación lineal que representa la matriz. Esto se devuelve como una matriz cuyo espacio de columna es el espacio nulo de `T`.

  Consulte Planetmath para obtener más información.

Nullity

      Nullity (M)

  Alias: `nullity`

  Obtener la nulidad de una matriz. Es decir, devuelve la dimensión del espacio nulo; la dimensión del núcleo de `M`.

  Consulte Planetmath para obtener más información.

OrthogonalComplement

      OrthogonalComplement (M)

  Obtener el complemento ortogonal del espacio de columnas.

PivotColumns

      PivotColumns (M)

  Devuelve las columnas pivote de una matriz, que son columnas que tienen un 1 en la fila forma reducida. También devuelve la fila en la que se producen.

Projection

      Projection (v,W,B...)

  Proyección del vector `v` sobre el sub-espacio `W` con respecto al propio producto dado por `B`. Si `B` no se da, entonces se usa el producto estándar Hermitiano. `B` puede también ser una función sesquilineal de dos argumentos o puede ser una matriz que devuelve una forma sesquilineal.

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 la Wikipedia o Planetmath o Mathworld para obtener más información.

RayleighQuotient

      RayleighQuotient (A,x)

  Devuelve el cociente de Rayleigh (también llamado el cociente de Rayleigh-Ritz o ratio) de una matriz y un vector.

  Consulte Planetmath para obtener más información.

RayleighQuotientIteration

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

  Buscar valores propios de `A` utilizando el método de iteración de cociente de Rayleigh. `x` es una conjetura en un vector propio que será aleatoria. Esto tendrá una parte imaginaria no nula si es posible encontrar valores propios complejos. El código ejecutará en la mayoría de las interacciones `maxiter` y devuelve `null` si no se puede obtener un error de `epsilon`. `vecref` será o bién un `null` o una referencia a una variable donde se guarde el vector propio.

  Conuslte Planetmath para obtener más información sobre el cociente de Rayleigh.

Rank

      Rank (M)

  Alias: `rank`

  Obtener el rango de una matriz.

  Consulte Planetmath para obtener más información.

RosserMatrix

      RosserMatrix ()

  Devolver la matriz de Rosser, que es un problemático y clásico test simétrico de valores propios.

Rotation2D

      Rotation2D (ángulo)

  Alias: `RotationMatrix`

  Devolver la matriz correspondiente a la rotación alrededor del origen en R2.

Rotation3DX

      Rotation3DX (ángulo)

  Devuelve la matriz correspondiente a la rotación alrededor del origen en R3 sobre el eje x.

Rotation3DY

      Rotation3DY (ángulo)

  Devolver la matriz correspondiente a la rotación alrededor del origen en R3 sobre el eje Y.

Rotation3DZ

      Rotation3DZ (ángulo)

  Devolver la matriz correspondiente a la rotación alrededor del origen en R3 sobre el eje Z.

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)

  Devuelve la forma normal de Smith de una matriz sobre los campos (terminará con unos en la diagonal).

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

SmithNormalFormInteger

      SmithNormalFormInteger (M)

  Devuelve la forma normal de Smith para matrices cuadradas sobre enteros.

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

SolveLinearSystem

      SolveLinearSystem (M,V,args...)

  Resuelve el sistema lineal Mx=V, devuelve la solución V si hay una única solución y `null` en cualquier otro caso. Opcionalmente, se pueden usar dos parámetros de referencia para obtener M y V reducidos.

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

  Consulte la Wikipedia o 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 la Wikipedia o Planetmath para obtener más información.

Transpose

      Transpose (M)

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

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

VandermondeMatrix

      VandermondeMatrix (v)

  Alias: `vander`

  Devuelve la matriz de Vandermonde.

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

VectorAngle

      VectorAngle (v,w,B...)

  El ángulo de dos vectores con respecto al propio producto viene dado por `B`. Si no se da `B`, entonces se usará el producto estándar Hermitiano. `B` puede ser una función sesquilineal de dos argumentos o bien, una matriz que devuelve una forma sesquilineal.

VectorSpaceDirectSum

      VectorSpaceDirectSum (M,N)

  Suma directa de los espacios vectoriales M y 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`

  Obtener el adjunto clásico de una matriz.

cref

      cref (M)

  Aliases: `CREF` `ColumnReducedEchelonForm`

  Calcular la forma en escalón reducida por columnas.

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)

  Aliases: `REF` `RowEchelonForm`

  Obtener la matriz escalonada por fila. Es decir, aplicar la eliminación gausiana pero no hacer la reducción a `M`. Las filas pivote están divididas para que todos los pivotes sean 1.

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

rref

      rref (M)

  Aliases: `RREF` `ReducedRowEchelonForm`

  Obtener la matriz escalonada reducida por filas. Es decir, aplicar la eliminación gausiana junto con la reducción a `M`.

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

### Combinatoria

Catalan

      Catalan (n)

  Obtener el `n`-ésimo número de Catalan.

  Consulte Planetmath para obtener más información.

Combinations

      Combinations (k,n)

  Obtener todas las combinaciones de «k» números desde 1 a «n» como un vector de vectores. (Consulte NextCombination)

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

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)

  Factorial descendente: `(n)_k = n(n-1)...(n-(k-1))`

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

Fibonacci

      Fibonacci (x)

  Alias: `fib`

  Calcular el `n`-ésimo número de Fibonacci. El número se define recursivamente por `Fibonacci(n) = Fibonacci(n-1) + Fibonacci(n-2)` y `Fibonacci(1) = Fibonacci(2) = 1`.

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

FrobeniusNumber

      FrobeniusNumber (v,arg...)

  Calcular el número de Frobenius. Calcular en número más grande que no se puede dar como una combinación de entero lineal no negativo de un vector dado de enteros no negativos. El vector se puede dar como números separados o un simple vector. Todos los números tendrán un máximo común divisor de enteros «GCD» de 1.

  Consulte la Wikipedia o 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_1+...+a_n*x_n=x_(n+1)).

GreedyAlgorithm

      GreedyAlgorithm (n,v)

  Buscar el vector `c` de enteros no negativos de tal manera que al realizar el producto escalar con `v` es igual a n. Si no es posible, se devuelve `null`. `v` estará ordenada de forma incremental y estará constituida de enteros no negativos.

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

HarmonicNumber

      HarmonicNumber (n,r)

  Alias: `HarmonicH`

  Número Armónico, el `n`-ésimo número armónico de orden `r`. Esto es, el sumatorio de `1/k^r` para `k` desde 1 a n. Equivalente a `sum k = 1 to n do 1/k^r`.

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

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

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

LinearRecursiveSequence

      LinearRecursiveSequence (seed_values,combining_rule,n)

  Calcular la sucesión lineal recursiva utilizando el escalamiento de Galois.

Multinomial

      Multinomial (v,arg...)

  Calcular los coeficientes multinomiales. Toma un vector de `k` enteros no negativos y calcula el coeficiente multinomial. Esto corresponde al coeficiente en el polinomio homogéneo en `k` variables con las correspondientes potencias.

  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 la Wikipedia, Planetmath, o Mathworld para obtener más información.

NextCombination

      NextCombination (v,n)

  Obtener las combinaciones que v devolverá después de su ejecución. La primera combinación será `[1:k]`. Esta función es útil si tiene muchas combinaciones que pasar y no quiere olvidarse de guardarlas todas.

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

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

  But with NextCombination you would write something like:

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

  See also Combinations.

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

Pascal

      Pascal (i)

  Obtener el triángulo de Pascal como una matriz. Esto devolverá una `i`+1 por `i`+1 la diagonal inferior de la matriz que es el triángulo de Pascal después de `i` iteraciones.

  Consulte Planetmath para obtener más información.

Permutations

      Permutations (k,n)

  Obtener todas las permutaciones de `k` números desde el 1 al `n` como un vector de vectores.

  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=0}^n (-1)^k/k!.

Triangular

      Triangular (nth)

  Calcular el `n`-ésimo número triangular.

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

nCr

      nCr (n,r)

  Alias: `Binomial`

  Calcular combinaciones, es decir, el coeficiente del binomio. `n` puede ser cualquier número real.

  Consulte Planetmath para obtener más información.

nPr

      nPr (n,r)

  Calcular el número de permutaciones de tamaño `r` de números desde el 1 al `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.

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

EvenPeriodicExtension

      EvenPeriodicExtension (f,L)

  Devolver una función que es una extensión periódica par de `f` con medio periodo `L`. Esto es una función que se define en el intervalo `[0,L]` extendido para ser par en `[-L,L]` y entonces extendido para ser periódico con periodo `2*L`.

  Consulte OddPeriodicExtension y PeriodicExtension.

  Desde la versión 1.0.7 en adelante.

FourierSeriesFunction

      FourierSeriesFunction (a,b,L)

  Devuelve una función que es una serie de Fourier con coeficientes devueltos por los vectores `a` (senos) y `b` (cosenos). Tenga en cuenta que `a@(1)` es el coeficiente constante. Es decir, `a@(n)` se refiere al término `cos(x*(n-1)*pi/L)`, mientras que `b@(n)` se refiere al término `sin(x*n*pi/L)`. Tanto `a` o `b` puede ser `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.

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

NumericalFourierSeriesCoefficients

      NumericalFourierSeriesCoefficients (f,L,N)

  Devuelve un vector de vectores `[a,b]` donde `a` son los coeficientes cosenos y `b` son los coeficientes senos de la serie de Fourier de `f` con medio periodo `L` (esto se define en `[-L,L]` y extendido periódicamente) con coeficientes hasta `N`-ésimo harmónico calculado numéricamente. Los coeficientes se calculan por la integración numérica al usar `NumericalIntegral`.

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

  Desde la versión 1.0.7 en adelante.

NumericalFourierSeriesFunction

      NumericalFourierSeriesFunction (f,L,N)

  Devuelve una función que es la serie de Fourier de `f` con medio periodo `L` (esto se define en `[-L,L]` y extendido periódicamente) con coeficientes hasta `N`-ésimo harmónico calculado numéricamente. Esto es, la serie trigonométrica real compuesta de senos y cosenos. Los coeficientes se calculan por la integración numérica al utilizar `NumericalIntegral`.

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

  Desde la versión 1.0.7 en adelante.

NumericalFourierCosineSeriesCoefficients

      NumericalFourierCosineSeriesCoefficients (f,L,N)

  Devuelve un vector de coeficientes de coseno de la serie de Fourier de `f` con medio periodo `L`. Es decir, se toma `f` definida en `[0,L]` toma la extensión periódica par y calcula la serie de Fourier, que sólo tiene cosenos como términos. La serie se calcula hasta la `N`-ésima harmónica. Los coeficientes se calculan por la integración numérica al utilizar `NumericalIntegral`. Tenga en cuenta que `a@(1)` es el coeficiente constante. Es decir, `a@(n)` se refiere a el término `cos(x*(n-1)*pi/L)`.

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

  Desde la versión 1.0.7 en adelante.

NumericalFourierCosineSeriesFunction

      NumericalFourierCosineSeriesFunction (f,L,N)

  Devuelve una función que es el coseno de la serie de Fourier de `f` con medio periodo `L`. Es decir, se toma `f` definida en `[0,L]` toma la extensión periódica par y calcula la serie de Fourier, que sólo tiene coseno como términos. La serie se calcula hasta la `N`-ésima harmónica. Los coeficientes se calculan por la integración numérica al utilizar `NumericalIntegral`.

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

  Desde la versión 1.0.7 en adelante.

NumericalFourierSineSeriesCoefficients

      NumericalFourierSineSeriesCoefficients (f,L,N)

  Devuelve un vector de coeficientes de senos de la serie de Fourier de `f` con medio periodo `L`. Es decir, se toma `f` definido en `[0,L]` toma la extensión periódica impar y calcula la serie de Fourier, que sólo tiene senos como términos. La serie se calcula hasta el `N`-ésimo harmónico. Los coeficientes se calculan por la integración numérica al utilizar `NumericalIntegral`.

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

  Desde la versión 1.0.7 en adelante.

NumericalFourierSineSeriesFunction

      NumericalFourierSineSeriesFunction (f,L,N)

  Devuelve una función que es el seno de la serie de Fourier de `f` con medio periodo `L`. Es decir, se toma `f` definida en `[0,L]` toma la extensión periódica impar y calcula ls series de Fourier, que sólo tiene seno como términos. La serie se calcula hasta la `N`-ésima harmónica. Los coeficientes se calculan por la integración numérica al utilizar `NumericalIntegral`.

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

  Desde la versión 1.0.7 en adelante.

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)

  Devuelve una función que es la extensión periódica impar de `f` con medio periodo `L`. Esto es una función definida en el intervalo `[0,L]` extendida para ser impar en `[-L,L]` y entonces extendida para ser periódica con periodo `2*L`.

  Consulte también EvenPeriodicExtension y PeriodicExtension.

  Desde la versión 1.0.7 en adelante.

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)

  Devuelve una función que es la extensión periódica de `f` que se define en el intervalo `[a,b]` y tiene un periodo `b-a`.

  Consulte también OddPeriodicExtension y EvenPeriodicExtension.

  Desde la versión 1.0.7 en adelante.

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)

  Aliases: `Arg` `arg`

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

BesselJ0

      BesselJ0 (x)

  Función de Bessel de primer tipo de orden 0. Implementada solo para números reales.

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

  Desde la versión 1.0.16 en adelante.

BesselJ1

      BesselJ1 (x)

  Función de Bessel de primer tipo de orden 1. Implementada solo para números reales.

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

  Desde la versión 1.0.16 en adelante.

BesselJn

      BesselJn (n,x)

  Función de Bessel de primer tipo de orden `n`. Implementada solo para números reales.

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

  Desde la versión 1.0.16 en adelante.

BesselY0

      BesselY0 (x)

  Función de Bessel de segundo tipo de orden 0. Implementada solo para números reales.

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

  Desde la versión 1.0.16 en adelante.

BesselY1

      BesselY1 (x)

  Función de Bessel de segunto tipo de orden 1. Implementada solo para números reales.

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

  Desde la versión 1.0.16 en adelante.

BesselYn

      BesselYn (n,x)

  Función de Bessel de segundo tipo de orden `n`. Implementada solo para números reales.

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

  Desde la versión 1.0.16 en adelante.

DirichletKernel

      DirichletKernel (n,t)

  Núcleo de Dirichlet de orden `n`.

DiscreteDelta

      DiscreteDelta (v)

  Devuelve 1 si y sólo 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 la Wikipedia o Planetmath para obtener más información.

FejerKernel

      FejerKernel (n,t)

  Núcleo de Fejer de orden `n` evaluado en `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 o Wikipedia para obtener más información.

KroneckerDelta

      KroneckerDelta (v)

  Devuelve 1 si y sólo si todos los elementos son iguales.

LambertW

      LambertW (x)

  La rama principal de la función de Lambert W calculada sólo para los valores reales más grandes o iguales que `-1/e`. Es decir, que la función `LambertW` es la inversa de la expresión `x*e^x`. Incluso para una variable real `x` esta expresión no es uno a uno y por lo tanto tiene dos ramas más `[-1/e,0)`. Consulte `LambertWm1` para otras ramas reales.

  Consulte la Wikipedia para más información.

  Desde la versión 1.0.18 en adelante.

LambertWm1

      LambertWm1 (x)

  La rama menos uno «-1» de la función de Lambert W calculada sólo para valores reales más grandes o igual a `-1/e` y menor que 0. Es decir, `LambertWm1` es la segunda rama de la inversa de `x*e^x`. Consulte `LambertW` para la rama principal.

  Consulte la Wikipedia para más información.

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 la Wikipedia o 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 la Wikipedia o 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 la Wikipedia o 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 la Wikipedia o 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 la Wikipedia o 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 o Wikipedia para 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.

sinc

      sinc (x)

  Calcular la función sinc no normalizada, esto es `sin(x)/x`. Si quiere normalizar la función utilice `sinc(pi*x)`.

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

  Desde la versión 1.0.16 en adelante.

### Resolución de ecuaciones

CubicFormula

      CubicFormula (p)

  Calcular las raíces de un polinomio cúbico (de grado 3) utilizando la fórmula cúbica. El polinomio se dará como un vector de coeficientes. Esto es `4*x^3 + 2*x + 1` que corresponde al vector `[1,2,0,4]`. Devuelve un vector columna de tres soluciones. La primera solución siempre es la real como un cúbico siempre tiene una solución real.

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

EulersMethod

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

  Utilizar el método clásico de Euler para resolver numéricamente y'=f(x,y) de forma inicial `x0`, `y0` pasan a `x1` con `n` incrementos, devuelve `y` junto con `x1`. Excepto que especifique explícitamente que quiere utilizar el método clásico de Euler, piense en utilizar RungeKutta para resolver ODE.

  Los sistemas se pueden resolver teniendo a `y` como un vector (columna) en cualquier parte. Es decir, `y0` puede ser un vector en cuyo caso `f` será un número `x` y un vector del mismo tamaño para el segundo argumento y devolverá un vector del mismo tamaño.

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

EulersMethodFull

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

  Utilizar el método clásico de Euler para resolver numéricamente y'=f(x,y) de forma inicial `x0`, `y0` pasan a `x1` con `n` incrementos, devuelve una matriz de 2 por `n+1` con los valores `x` e `y`.Excepto que quiera utilizar explícitamente el método clásico de Euler, utilice mejor RungeKuttaFull para resolver ODE. Adecuado para enlazar con LinePlotDrawLine o LinePlotDrawPoints.

  Example:

      genius> LinePlotClear();
      genius> line = EulersMethodFull(`(x,y)=y,0,1.0,3.0,50);
      genius> LinePlotDrawLine(line,"window","fit","color","blue","legend","Exponential growth");

  Los sistemas se pueden resolver teniendo a `y` como un vector (columna) en cualquier parte. Es decir, `y0` puede ser un vector en cuyo caso `f` será un número `x` y un vector del mismo tamaño para el segundo argumento y devolverá un vector del mismo tamaño.

  The output for a system is still a n by 2 matrix with the second entry being a vector. If you wish to plot the line, make sure to use row vectors, and then flatten the matrix with ExpandMatrix, and pick out the right columns. Example:

      genius> LinePlotClear();
      genius> lines = EulersMethodFull(`(x,y)=[y@(2),-y@(1)],0,[1.0,1.0],10.0,500);
      genius> lines = ExpandMatrix(lines);
      genius> firstline = lines@(,[1,2]);
      genius> secondline = lines@(,[1,3]);
      genius> LinePlotWindow = [0,10,-2,2];
      genius> LinePlotDrawLine(firstline,"color","blue","legend","First");
      genius> LinePlotDrawPoints(secondline,"color","red","thickness",3,"legend","Second");

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

  Desde la versión 1.0.10 en adelante.

FindRootBisection

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

  Buscar la raíz de una función utilizando el método de la bisección. `a` y `b` son los límites iniciales del intervalo, `f(a)` y `f(b)` deben tener signos opuestos. `TOL` es la tolerancia deseada y `N` es el límite del número de iteraciones a ejecutar, 0 indica sin límites. La función devuelve un vector `[success,value,iteration]`, donde `success` un booleano que indica el éxito, `value` es el último valor calculado, e `iteration` es el número de iteraciones realizadas.

FindRootFalsePosition

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

  Buscar la raíz de una función utilizando el método de la posición falsa. `a` y `b` son los valores iniciales del intervalo, `f(a)` y `f(b)` deben tener signos opuestos. `TOL` es la tolerancia deseada y `N` es el límite del número de iteraciones a ejecutar, 0 indica sin límites. La función devuelve un vector `[success,value,iteration]`, donde `success` es un booleano que indica el éxito, `value` es el último valor calculado, e `iteration` es el número de iteraciones realizadas.

FindRootMullersMethod

      FindRootMullersMethod (f,x0,x1,x2,TOL,N)

  Buscar la raíz de una función utilizando el método de Muller. `TOL` es la tolerancia deseada y `N` es el límite del número de iteraciones a ejecutar, 0 indica sin límites. La función devuelve un vector `[success,value,iteration]`, donde `success` un booleano que indica el éxito, `value` es el último valor calculado, e `iteration` es el número de iteraciones realizadas.

FindRootSecant

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

  Buscar la raíz de una función utilizando el método de la secante. `a` y `b` son los límites iniciales del intervalo, `f(a)` y `f(b)` deben tener signos opuestos. `TOL` es la tolerancia deseada y `N` es el límite del número de iteraciones a ejecutar, 0 indica sin límites. La función devuelve un vector `[success,value,iteration]`, donde `success` es un booleano que indica el éxito, `value` es el último valor calculado, e `iteration` es el número de iteraciones realizadas.

HalleysMethod

      HalleysMethod (f,df,ddf,guess,epsilon,maxn)

  Encontrar ceros utilizando el método de Halleys. Siendo `f` la función, `df` es la derivada de `f`, y `ddf` es la segunda derivada de `f`. La variable `guess` es la aproximación inicial. La función devuelve después dos valores sucesivos que están dentro de los límites que marca `epsilon` o después de `maxn` iteraciones en cuyo caso devuelve `null` indicando un fallo.

  Consulte también `NewtonsMethod` y `SymbolicDerivative`.

  Example to find the square root of 10:

      genius> HalleysMethod(`(x)=x^2-10,`(x)=2*x,`(x)=2,3,10^-10,100)

  Consulte la Wikipedia para más información.

  Desde la versión 1.0.18 en adelante.

NewtonsMethod

      NewtonsMethod (f,df,guess,epsilon,maxn)

  Encontrar ceros utilizando el método de Newton. La variable `f` es la función y `df` es la derivada de `f`. La variable `guess` el supuesto inicial. La función devuelve después dos valores sucesivos que están dentro de los límites que marca `epsilon` o después de `maxn` iteraciones en cuyo caso devuelve `null` indicando un fallo.

  Consulte también `NewtonsMethodPoly` y `SymbolicDerivative`.

  Example to find the square root of 10:

      genius> NewtonsMethod(`(x)=x^2-10,`(x)=2*x,3,10^-10,100)

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

  Desde la versión 1.0.18 en adelante.

PolynomialRoots

      PolynomialRoots (p)

  Calcular las raíces de un polinomio (de grado 1 a 4) utilizando una de las fórmulas para cada polinomio. El polinomio entregará un vector de coeficientes. Esto es `4*x^3 + 2*x + 1` que corresponde al vector `[1,2,0,4]`. Devuelve un vector columna de las soluciones.

  La función llama a QuadraticFormula, CubicFormula, y a QuarticFormula.

QuadraticFormula

      QuadraticFormula (p)

  Calcular las raíces de una polinomio cuadrático (de grado 2) utilizando la fórmula cuadrática. El polinomio será un vector de coeficientes. Es es `3*x^2 + 2*x + 1` que corresponde con el vector `[1,2,3]`. Devuelve un vector columna de las dos soluciones.

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

QuarticFormula

      QuarticFormula (p)

  Calcular las raíces de un polinomio cuadrático (de grado 4) utilizando la fórmula cuadrática. El polinomio será un vector de coeficientes. Esto es `5*x^4 + 2*x + 1` que corresponde con el vector `[1,2,0,0,5]`. Devuelve un vector columna de las cuatro soluciones.

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

RungeKutta

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

  Utilizar el método clásico no adaptativo de cuarto orden Runge-Kutta para resolver numéricamente y'=f(x,y) que de forma inicial `x0`, `y0` tienden a `x1` con `n` incrementos, devuelve `y` en `x1`.

  Los sistemas se pueden resolver teniendo a `y` como un vector (columna) en cualquier parte. Es decir, `y0` puede ser un vector en cuyo caso `f` será un número `x` y un vector del mismo tamaño para el segundo argumento y devolverá un vector del mismo tamaño.

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

RungeKuttaFull

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

  Utilizar el método clásico no adaptativo de cuarto orden Runge-Kutta para resolver numéricamente y'=f(x,y) que de forma inicial `x0`, `y0` tienden a `x1` con `n` incrementos, devuelve una matriz de 2 por `n+1` con los valores `x` e `y`. Adecuado para enlazar con LinePlotDrawLine o LinePlotDrawPoints.

  Example:

      genius> LinePlotClear();
      genius> line = RungeKuttaFull(`(x,y)=y,0,1.0,3.0,50);
      genius> LinePlotDrawLine(line,"window","fit","color","blue","legend","Exponential growth");

  Los sistemas se pueden resolver teniendo a `y` como un vector (columna) en cualquier parte. Es decir, `y0` puede ser un vector en cuyo caso `f` será un número `x` y un vector del mismo tamaño para el segundo argumento y devolverá un vector del mismo tamaño.

  The output for a system is still a n by 2 matrix with the second entry being a vector. If you wish to plot the line, make sure to use row vectors, and then flatten the matrix with ExpandMatrix, and pick out the right columns. Example:

      genius> LinePlotClear();
      genius> lines = RungeKuttaFull(`(x,y)=[y@(2),-y@(1)],0,[1.0,1.0],10.0,100);
      genius> lines = ExpandMatrix(lines);
      genius> firstline = lines@(,[1,2]);
      genius> secondline = lines@(,[1,3]);
      genius> LinePlotWindow = [0,10,-2,2];
      genius> LinePlotDrawLine(firstline,"color","blue","legend","First");
      genius> LinePlotDrawPoints(secondline,"color","red","thickness",3,"legend","Second");

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

  Desde la versión 1.0.10 en adelante.

### Estadísticas

Average

      Average (m)

  Aliases: `average` `Mean` `mean`

  Calcular la media aritmética de una matriz entera.

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

GaussDistribution

      GaussDistribution (x,sigma)

  Integral de la función de Gauss desde 0 a `x` (área debajo de la curva normal).

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

GaussFunction

      GaussFunction (x,sigma)

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

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

Median

      Median (m)

  Alias: `median`

  Calcular la mediana de una matriz entera.

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

PopulationStandardDeviation

      PopulationStandardDeviation (m)

  Alias: `stdevp`

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

RowAverage

      RowAverage (m)

  Alias: `RowMean`

  Calcular la media de cada fila de una matriz. Es decir, calcula la media aritmética.

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

RowMedian

      RowMedian (m)

  Calcular la mediana de cada fila en una matriz y devolver una vector columna de las medianas.

  Consulte la Wikipedia o 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)

  Dividir dos polinomios (como vectores) utilizando la división larga. Devuelve el cociente de los dos polinomios. El argumento opcional `r` se utiliza para devolver el residuo. El residuo tendrá el grado más bajo que `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)

  Encontrar una raíz de un polinomio utilizando el método de Newton. La variable `poly` es el polinomio en forma vectorial y `guess` es la suposición inicial. La función devuelve después dos valores sucesivos que están dentro de los límites que marca `epsilon` o después de `maxn` iteraciones en cuyo caso devuelve `null` indicando un fallo.

  Consulte también `NewtonsMethod`.

  Example to find the square root of 10:

      genius> NewtonsMethodPoly([-10,0,1],3,10^-10,100)

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

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)

  Devuelve `true` si `X` es un subconjunto de `Y` (`X` e `Y` son vectores que se tratan como conjuntos).

IsSubset

      IsSubset (X, Y)

  Devuelve `true` si `X` es un subconjunto de `Y` (`X` e `Y` son vectores que se tratan como conjuntos).

MakeSet

      MakeSet (X)

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

SetMinus

      SetMinus (X,Y)

  Devuelve un conjunto teorético de diferencia X-Y (X e Y son vectores que pretender ser conjuntos).

Union

      Union (X,Y)

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

### Álgebra conmutativa

MacaulayBound

      MacaulayBound (c,d)

  Para una función de Hilbert que es c de grado d, dada la función de Macaulay obligado por la función de Hilbert de grado d+1 (el c^<d> operador de la prueba de Green).

  Desde la versión 1.0.15 en adelante.

MacaulayLowerOperator

      MacaulayLowerOperator (c,d)

  El operador c_<d> de la prueba de Green del teorema de Macaulay.

  Desde la versión 1.0.15 en adelante.

MacaulayRep

      MacaulayRep (c,d)

  Devolver la representación dth de Macaulay de un entero positivo c.

  Desde la versión 1.0.15 en adelante.

### Miscelánea

ASCIIToString

      ASCIIToString (vec)

  Convierte un vector de valores ASCII en una cadena. Consulte `StringToASCII` para más información.

  Example:

      genius> ASCIIToString([97,98,99])
      = "abc"

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

AlphabetToString

      AlphabetToString (vec,alfabeto)

  Convertir un vector de valores alfanuméricos en base 0 (posiciones alfanuméricas de la cadena) a una cadena. Un `null` vector da como resultado una cadena vacía. Consulte mas información en `StringToAlphabet`.

  Examples:

      genius> AlphabetToString([1,2,3,0,0],"abcd")
      = "bcdaa"
      genius> AlphabetToString(null,"abcd")
      = ""

StringToASCII

      StringToASCII (cad)

  Convertir una cadena a un vector (fila) de valores ASCII. Consulte también `ASCIIToString`.

  Example:

      genius> StringToASCII("abc")
      = [97, 98, 99]

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

StringToAlphabet

      StringToAlphabet (str,alfabeto)

  Convierte una cadena a un (fila) vector de valores alfabeticos en base 0 (posiciones en la cadena alfabetica), siendo -1 para caracteres desconocidos. Una cadena vacía será el resultado de una constante `null`. Consulte para más información en `AlphabetToString`.

  Examples:

      genius> StringToAlphabet("cca","abcd")
      = [2, 2, 0]
      genius> StringToAlphabet("ccag","abcd")
      = [2, 2, 0, -1]

### Operaciones simbólicas

SymbolicDerivative

      SymbolicDerivative (f)

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

  Examples:

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

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

SymbolicDerivativeTry

      SymbolicDerivativeTry (f)

  Intentar diferenciar simbólicamente la función f, donde f es una función de una variable, devuelve `null` si no es satisfactoria pero es silenciosa. (Consulte `SymbolicDerivative`)

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

SymbolicNthDerivative

      SymbolicNthDerivative (f,n)

  Intentar diferenciar simbólicamente una función n veces. (Consulte `SymbolicDerivative`)

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

SymbolicNthDerivativeTry

      SymbolicNthDerivativeTry (f,n)

  Intentar diferenciar simbólicamente una función n veces de manera silenciosa y devolver `null` en caso de fallo. (Consulte `SymbolicNthDerivative`)

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

SymbolicTaylorApproximationFunction

      SymbolicTaylorApproximationFunction (f,x0,n)

  Intenta construir la aproximación de Taylor alrededor de x0 hasta grado n. (Consulte `SymbolicDerivative`)

### Dibujar

ExportPlot

      ExportPlot (archivo,tipo)

      ExportPlot (archivo)

  Exportar el contenido de la ventana de dibujado a un archivo. El tipo es una cadena que especifica el tipo de archivo que usar, «png», «eps» o «ps». Si no se especifica el tipo, se toma a partir de la extensión, en cuyo caso debe ser«.png», «.eps» o «.ps».

  Tenga en cuneta que los archivos se sobreescriben sin preguntar.

  Al exportar correctamente, se devuelve. Si falla algo, se muestra un error y se eleva una excepción.

  Examples:

      genius> ExportPlot("file.png")
      genius> ExportPlot("/directory/file","eps")

  Desde la versión 1.0.16 en adelante.

LinePlot

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

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

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

      LinePlot (func1,func2,func3,[x1,x2])

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

  Dibujar una función (o varias funciones) con una línea. Los 10 primeros argumentos son funciones, entonces opcionalmente puede especificar los límites de las gráficas como `x1`, `x2`, `y1`, `y2`. Si no se especifican los límites, entonces se aplican los límites actuales (Consulte `LinePlotWindow`). Si no se especifican los límites de y, las funciones se calculan y se usan las áreas máxima y mínima.

  El parámetro `LinePlotDrawLegends` controla el dibujado de la leyenda.

  Examples:

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

LinePlotClear

      LinePlotClear ()

  Muestra la ventana de dibujo lineal y limpia las funciones y otras líneas que se hubiesen dibujado.

LinePlotCParametric

      LinePlotCParametric (func,...)

      LinePlotCParametric (func,t1,t2,tinc)

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

  Dibujar una función valorada paramétrica compleja con una línea. Primero vienen las funciones que devuelven `x+iy`, luego, opcionalmente, los `t` límites como `t1,t2,tinc`, y límites como `x1,x2,y1,y2`.

  Si los límites no se especifican, entonces se aplican las configuraciones actuales (Consulte `LinePlotWindow`). Si en lugar de la cadena se da el valor «fit» para los límites x e y, los límites son la medida máxima de la gráfica.

  El parámetro `LinePlotDrawLegends` controla el dibujado de la leyenda.

LinePlotDrawLine

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

      LinePlotDrawLine (v,...)

  Dibuja una línea desde `x1`,`y1` a `x2`,`y2`. Es posible reemplazar `x1`,`y1`, `x2`,`y2` por una matriz de `n` por 2 para obtener una curva poligonal de mayor longitud. También el vector `v` puede ser un vector columna de números complejos, esto es una matriz `n` por 1 y cada número complejo se considera un punto en el plano.

  Se pueden añadir parámetros adicionales para especificar el color de la línea, ancho, flechas, ventanas de dibujado o leyendas. Puede modificarlo añadiendo un valor a `«color»`, `«ancho»`, `«ventana»`, `«flecha»`, o `«leyenda»`, y después especificar su color, la anchura, la ventana como 4 vectores, tipo de flecha, o la leyenda. (Flecha y ventana están desde la versión 1.0.6 y posteriores.)

  Si la línea se considera como un polígono relleno, relleno con el color dado, se puede especificar el argumento `«llenado»`. Desde la versión 1.0.22 en adelante.

  La denominación del color debe ser una cadena que identifique al color según el diccionario inglés que GTK reconocerá como `«red»`, `«blue»`, `«yellow»`, etc... De forma alternativa el color se puede especificar en formato RGB como por ejemplo `«#rgb»`, `«#rrggbb»`, o `«#rrrrggggbbbb»`, donde r, g, o b son dígitos hexadecimales de los colores rojo, verde y azul (red, green, blue) . Finalmente, desde la versión 1.0.18, los colores se pueden especificar como vectores siendo el rojo, verde y azul componentes con valores que solo pueden ser 0 o 1. Por ejemplo: `[1.0,0.5,0.1]`.

  Los valores de entrada de la ventana deben ser del tipo `[x1,x2,y1,y2]`, o bien, pueden ser una cadena `«ajuste»`, en cualquier caso, el rango de x se establecerá con precisión y el rango y se puede ajustar con cinco por ciento alrededor del borde de la línea.

  La especificación para la flecha debería ser `«origen»`, `«fin»`, `«ambos»`, o `«ninguno»`.

  Finalmente, la leyenda debería ser una cadena que se pueda utilizar como leyenda en un gráfico. Es decir, si se imprimen las leyendas.

  Examples:

      genius> LinePlotDrawLine(0,0,1,1,"color","blue","thickness",3)
      genius> LinePlotDrawLine([0,0;1,-1;-1,-1])
      genius> LinePlotDrawLine([0,0;1,1],"arrow","end")
      genius> LinePlotDrawLine(RungeKuttaFull(`(x,y)=y,0,0.001,10,100),"color","blue","legend","The Solution")
      genius> for r=0.0 to 1.0 by 0.1 do LinePlotDrawLine([0,0;1,r],"color",[r,(1-r),0.5],"window",[0,1,0,1])
      genius> LinePlotDrawLine([0,0;10,0;10,10;0,10],"filled","color","green")

  A diferencia de muchas otras funciones que no les importa si toman una columna o un vector fila, si se especifican puntos como un vector de valores complejos, debido a las posibles ambigüedades, es preferible que sea un vector columna.

  La especificación de `v` como un vector columna de números complejos, se implementa desde la versión 1.0.22 en adelante.

LinePlotDrawPoints

      LinePlotDrawPoints (x,y,...)

      LinePlotDrawPoints (v,...)

  Dibuja un punto en `x`,`y`. La entrada puede ser una matriz `n` por 2 para `n` puntos diferentes. Esta función es esencialmente la misma entrada que LinePlotDrawLine. De forma alternativa, el vector `v` puede ser un vector columna de números complejos, esto es una matriz `n` por 1 y cada número complejo se considera un punto en el plano.

  Se pueden añadir parámetros adicionales para especificar el color, ancho, ventanas de dibujado o leyendas. Puede modificarlo añadiendo la palabra `«color»`, `«ancho»`, `«ventana»`, o `«leyenda»`, y después especificar su color, la anchura, la ventana como 4 vectores, o la leyenda.

  La denominación del color debe ser una cadena que identifique al color según el diccionario inglés que GTK reconocerá como `«red»`, `«blue»`, `«yellow»`, etc... De forma alternativa el color se puede especificar en formato RGB como por ejemplo `«#rgb»`, `«#rrggbb»`, o `«#rrrrggggbbbb»`, donde r, g, o b son dígitos hexadecimales de los colores rojo, verde y azul (red, green, blue) . Finalmente los colores se pueden especificar como vectores siendo el rojo, verde y azul componentes con valores que solo pueden ser 0 o 1.

  Los valores de entrada de la ventana deben ser del tipo `[x1,x2,y1,y2]`, o bien, pueden ser una cadena `«ajuste»`, en cualquier caso, el rango de x se establecerá con precisión y el rango y se puede ajustar con cinco por ciento alrededor del borde de la línea.

  Finalmente, la leyenda debería ser una cadena que se pueda utilizar como leyenda en un gráfico. Es decir, si se imprimen las leyendas.

  Examples:

      genius> LinePlotDrawPoints(0,0,"color","blue","thickness",3)
      genius> LinePlotDrawPoints([0,0;1,-1;-1,-1])
      genius> LinePlotDrawPoints(RungeKuttaFull(`(x,y)=y,0,0.001,10,100),"color","blue","legend","The Solution")
      genius> LinePlotDrawPoints([1;1+1i;1i;0],"thickness",5)
      genius> LinePlotDrawPoints(ApplyOverMatrix((0:6)',`(k)=exp(k*2*pi*1i/7)),"thickness",3,"legend","The 7th roots of unity")

  A diferencia de muchas otras funciones que no les importa si toman una columna o un vector fila, si se especifica los puntos como un vector de valores complejos, debido a las posibles ambigüedades, siempre debe ser suministrado como un vector columna. Por lo tanto, la notificación en el último ejemplo la transpuesta del vector `0:6` para convertirlo en un vector columna.

  Disponible desde la versión 1.0.18 en adelante. La especificación de `v` como un vector columna de números complejos, se implementa desde la versión 1.0.22 en adelante.

LinePlotMouseLocation

      LinePlotMouseLocation ()

  Devuelve un vector fila de un punto de la línea de la pantalla de dibujado correspondiente a la ubicación actual del ratón. Si la trama de línea no es visible, entonces imprime un error y devuelve `null` . En este caso se debe ejecutar `LinePlot` o `LinePlotClear` para poner la ventana en el modo de dibujado de lineas. Consulte también `LinePlotWaitForClick`.

LinePlotParametric

      LinePlotParametric (xfunc,yfunc,...)

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

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

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

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

  Dibujar una función paramétrica con una línea. Primero vienen las funciones para `x` e `y` luego opcionalmente los `t` límites como `t1,t2,tinc`, y luego, opcionalmente, los límites como `x1,x2,y1,y2`.

  Si no se especifican los límites x e y, entonces se aplican las configuraciones actuales (Consulte `LinePlotWindow`). Si en lugar de la cadena se da el valor «fit» para los límites x e y, los límites son la medida máxima de la gráfica.

  El parámetro `LinePlotDrawLegends` controla el dibujado de la leyenda.

LinePlotWaitForClick

      LinePlotWaitForClick ()

  Si está en el modo de dibujado de lineas, espera por un clic en la ventana de dibujado de lineas y devuelve la ubicación del clic como un vector fila. Si se cierra la ventana de la función devuelve inmediatamente con `null`. Si la ventana no está en modo de dibujado de lineas, esta se pone de forma automática. Consulte también `LinePlotMouseLocation`.

PlotCanvasFreeze

      PlotCanvasFreeze ()

  Congela el dibujo en el lienzo de dibujado de forma temporal. Esto es útil si necesita dibujar un grupo de elementos y quiere demorar el dibujado para no permitir el parpadeo de una animación. Después de terminar con el dibujo debería descongelar el lienzo de dibujado llamando a la función `PlotCanvasThaw`.

  El lienzo está siempre desbloqueado hasta el final de cualquier proceso, así que nunca permanece bloqueado. El momento en que se muestra una nueva línea de comandos, por ejemplo, el lienzo de dibujado se descongela automáticamente. También tenga en cuenta que las llamadas a congelar y descongelar puede anidarse de manera segura.

  Desde la versión 1.0.18 en adelante.

PlotCanvasThaw

      PlotCanvasThaw ()

  Descongela el lienzo de dibujado congelado por la función `PlotCanvasFreeze` y volver a dibujar el lienzo inmediatamente. El lienzo también se descongelará al finalizar la ejecución de cualquier programa.

  Desde la versión 1.0.18 en adelante.

PlotWindowPresent

      PlotWindowPresent ()

  Muestra y eleva la ventana de dibujo, creándola si es necesario. Normalmente, la ventana se crea cuando se invoca a una de las funciones de dibujo, pero no siempre la eleva si está debajo de otra ventana. Esta función es buena para utilizar en un archivo de órdenes llamado «script» en inglés, donde la ventana de dibujo ha sido creada anteriormente, y por ahora, oculta detrás de la consola u otras ventanas.

  Desde la versión 1.0.19 en adelante.

SlopefieldClearSolutions

      SlopefieldClearSolutions ()

  Borra las soluciones elaboradas por la función `SlopefieldDrawSolution`.

SlopefieldDrawSolution

      SlopefieldDrawSolution (x, y, dx)

  Cuando un campo de dibujo de gráficas está activo, dibuja una solución con las condiciones iniciales especificas. El método estándar de Runge-Kutta se usa con incremento `dx`. Las soluciones permanecen en la gráfica hasta que se muestre un dibujo diferente o se llame a `SlopefieldClearSolutions`. También puede utilizar la interfaz gráfica para dibujar soluciones y especificar las condiciones iniciales con el ratón.

SlopefieldPlot

      SlopefieldPlot (func)

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

  Dibujar un campo inclinado. La función `func` tomará dos números reales `x` e `y`, o un número complejo. De manera opcional se especificarán los límites de la ventana de dibujo con `x1`, `x2`, `y1`, `y2`. Si no se especifica ningún límite, se aplicarán los que estén configurados actualmente (Consulte `LinePlotWindow`).

  El parámetro `LinePlotDrawLegends` controla el dibujado de la leyenda.

  Examples:

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

SurfacePlot

      SurfacePlot (func)

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

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

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

      SurfacePlot (func,[x1,x2,y1,y2])

  Dibujar una función superficial que tome entre dos argumentos o un número complejo. Primero vienen las funciones que las limitan de forma opcional `x1`, `x2`, `y1`, `y2`, `z1`, `z2`. Si no se especifican los límites, entonces las configuraciones actuales se aplicarán (Consulte `SurfacePlotWindow`). Genius sólo puede dibujar una función superficial sencilla por el momento.

  Si no se especifican los límites de z, se usan los valores máximo y mínimo de la función.

  Examples:

      genius> SurfacePlot(|sin|,-1,1,-1,1,0,1.5)
      genius> SurfacePlot(`(x,y)=x^2+y,-1,1,-1,1,-2,2)
      genius> SurfacePlot(`(z)=|z|^2,-1,1,-1,1,0,2)

SurfacePlotClear

      SurfacePlotClear ()

  Muestra la ventana de dibujo lineal y limpia las funciones y otras líneas que se hubiesen dibujado.

  Disponible en la versión 1.0.19 y posteriores.

SurfacePlotData

      SurfacePlotData (datos)

      SurfacePlotData (datos,etiqueta)

      SurfacePlotData (datos,x1,x2,y1,y2,z1,z2)

      SurfacePlotData (datos,etiqueta,x1,x2,y1,y2,z1,z2)

      SurfacePlotData (datos,[x1,x2,y1,y2,z1,z2])

      SurfacePlotData (datos,etiqueta,[x1,x2,y1,y2,z1,z2])

  Dibujar una superficie a partir de los datos. Los datos son una matriz de n x 3 cuyas filas son las coordenadas x, y, z. Los datos pueden ser un vector cuya longitud sea múltiplo de 3 y que contenga los triples de x, y z. Los datos deben contener al menos 3 puntos.

  Opcionalmente, se pueden indicar una etiqueta y los límites. Si no se indican los límites, se calculan a partir de los datos, no se usa `SurfacePlotWindow` pero, si quiere usarla, debe pasarla explícitamente. Si no se indica una etiqueta, se usa una etiqueta vacía.

  Examples:

      genius> SurfacePlotData([0,0,0;1,0,1;0,1,1;1,1,3])
      genius> SurfacePlotData(data,"My data")
      genius> SurfacePlotData(data,-1,1,-1,1,0,10)
      genius> SurfacePlotData(data,SurfacePlotWindow)

  Here's an example of how to plot in polar coordinates, in particular how to plot the function `-r^2 * theta`:

      genius> d:=null; for r=0 to 1 by 0.1 do for theta=0 to 2*pi by pi/5 do d=[d;[r*cos(theta),r*sin(theta),-r^2*theta]];
      genius> SurfacePlotData(d)

  Desde la versión 1.0.16 en adelante.

SurfacePlotDataGrid

      SurfacePlotDataGrid (datos,[x1,x2,y1,y2])

      SurfacePlotDataGrid (datos,[x1,x2,y1,y2,z1,z2])

      SurfacePlotDataGrid (datos,[x1,x2,y1,y2],etiqueta)

      SurfacePlotDataGrid (datos,[x1,x2,y1,y2,z1,z2],etiqueta)

  Dibujar una superficie a partir de datos rectangulares regulares. Los datos se dan en una matriz matriz de n x m donde las filas son la coordenada x y las columnas son la coordenada y. La coordenada x se divide en n-1 subintervalos iguales y la coordenada y se divide en m-1 subintervalos iguales. Los límites `x1` y `x2` dan el intervalo en el eje x usado y los límites `y1` e `y2` dan el intervalo en el eje y usado. Si los límites `z1` y `z2` no se indican, se calculan a partir de los datos (para obtener valores extremos de los datos).

  Opcionalmente se puede indicar la etiqueta; si no se indica ninguna, se unas una etiqueta vacía.

  Examples:

      genius> SurfacePlotDataGrid([1,2;3,4],[0,1,0,1])
      genius> SurfacePlotDataGrid(data,[-1,1,-1,1],"My data")
      genius> d:=null; for i=1 to 20 do for j=1 to 10 do d@(i,j) = (0.1*i-1)^2-(0.1*j)^2;
      genius> SurfacePlotDataGrid(d,[-1,1,0,1],"half a saddle")

  Desde la versión 1.0.16 en adelante.

SurfacePlotDrawLine

      SurfacePlotDrawLine (x1,y1,z1,x2,y2,z2,...)

      SurfacePlotDrawLine (v,...)

  Dibuja una línea desde `x1`,`y1`,`z1` hasta `x2`,`y2`,`z2`. `x1`,`y1`,`z1`, `x2`,`y2`,`z2` se puede reemplazar por una matriz de `n` por 3 para obtener una curva poligonal de mayor longitud.

  Se pueden añadir parámetros adicionales para especificar el color de la línea, ancho, ventanas de dibujado o leyendas. Puede modificarlo añadiendo un valor a `«color»`, `«ancho»`, `«ventana»`,o `«leyenda»`, y después especificar su color, la anchura, la ventana como 6 vectores, o la leyenda.

  La denominación del color debe ser una cadena que identifique al color según el diccionario inglés que GTK reconocerá como `«red»`, `«blue»`, `«yellow»`, etc... De forma alternativa el color se puede especificar en formato RGB como por ejemplo `«#rgb»`, `«#rrggbb»`, o `«#rrrrggggbbbb»`, donde r, g, o b son dígitos hexadecimales de los colores rojo, verde y azul (red, green, blue) . Finalmente, desde la versión 1.0.18, los colores se pueden especificar como vectores siendo el rojo, verde y azul componentes con valores que solo pueden ser 0 o 1. Por ejemplo: `[1.0,0.5,0.1]`.

  Los valores de entrada de la ventana deben ser del tipo `[x1,x2,y1,y2,z1,z2]`, o bien, pueden ser una cadena `«ajuste»`, en cualquier caso, el rango de x se establecerá con precisión y el rango y se puede ajustar con cinco por ciento alrededor del borde de la línea.

  Finalmente, la leyenda debería ser una cadena que se pueda utilizar como leyenda en un gráfico. Es decir, si se imprimen las leyendas.

  Examples:

      genius> SurfacePlotDrawLine(0,0,0,1,1,1,"color","blue","thickness",3)
      genius> SurfacePlotDrawLine([0,0,0;1,-1,2;-1,-1,-3])

  Disponible desde la versión 1.0.19 en adelante.

SurfacePlotDrawPoints

      SurfacePlotDrawPoints (x,y,z,...)

      SurfacePlotDrawPoints (v,...)

  Dibuja un punto en `x`,`y`,`z`. La entrada puede ser una `n` por 3 matriz para `n` puntos diferentes. Esta función es esencialmente la misma entrada que SurfacePlotDrawLine.

  Se pueden añadir parámetros adicionales para especificar el color de la línea, ancho, ventanas de dibujado o leyendas. Puede modificarlo añadiendo un valor a `«color»`, `«ancho»`, `«ventana»`,o `«leyenda»`, y después especificar su color, la anchura, la ventana como 6 vectores, o la leyenda.

  La denominación del color debe ser una cadena que identifique al color según el diccionario inglés que GTK reconocerá como `«red»`, `«blue»`, `«yellow»`, etc... De forma alternativa el color se puede especificar en formato RGB como por ejemplo `«#rgb»`, `«#rrggbb»`, o `«#rrrrggggbbbb»`, donde r, g, o b son dígitos hexadecimales de los colores rojo, verde y azul (red, green, blue) . Finalmente los colores se pueden especificar como vectores siendo el rojo, verde y azul componentes con valores que solo pueden ser 0 o 1.

  Los valores de entrada de la ventana deben ser del tipo `[x1,x2,y1,y2,z1,z2]`, o bien, pueden ser una cadena `«ajuste»`, en cualquier caso, el rango de x se establecerá con precisión y el rango y se puede ajustar con cinco por ciento alrededor del borde de la línea.

  Finalmente, la leyenda debería ser una cadena que se pueda utilizar como leyenda en un gráfico. Es decir, si se imprimen las leyendas.

  Examples:

      genius> SurfacePlotDrawPoints(0,0,0,"color","blue","thickness",3)
      genius> SurfacePlotDrawPoints([0,0,0;1,-1,2;-1,-1,1])

  Disponible desde la versión 1.0.19 en adelante.

VectorfieldClearSolutions

      VectorfieldClearSolutions ()

  Limpia las soluciones realizadas por la función `VectorfieldDrawSolution`.

  Desde la versión 1.0.16 en adelante.

VectorfieldDrawSolution

      VectorfieldDrawSolution (x, y, dt, tlen)

  Cuando un campo de dibujo vectorial está activo, dibuja una solución con las condición específica inicial. El método estándar de Runge-Kutta se utiliza con incremento `dt` para un intervalo de longitud `tlen`. Las soluciones permanecen en la gráfica hasta que se muestra un dibujo diferente o hasta que se llama a `VectorfieldClearSolutions`. Puede también utilizar la gráfica para dibujar soluciones y especificar las condiciones iniciales con el ratón.

  Desde la versión 1.0.16 en adelante.

VectorfieldPlot

      VectorfieldPlot (funcx, funcy)

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

  Dibujar un vector bidimensional. La función `funcx` será la dx/dt del campo vectorial y la función `funcy` la dy/dt del campo vectorial. Las funciones tomarán dos números reales `x` e `y`, o un simple número complejo. Cuando el parámetro `VectorfieldNormalized` es `true`, la magnitud de los vectores se normaliza. Es decir, sólo se muestra la dirección y no la magnitud.

  De manera opcional puede especificar los límites de la ventana de dibujo como `x1`, `x2`, `y1`, `y2`. Si no se especifican los límites, entonces se aplicará los actuales (Consulte `LinePlotWindow`).

  El parámetro `LinePlotDrawLegends` controla el dibujado de la leyenda.

  Examples:

      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("MyOwnREF: argument not a value only matrix");bailout);
      s := min(rows(m), columns(m));
      i := 1;
      d := 1;
      while d <= s and i <= columns(m) do (

        # This just makes the anchor element non-zero if at
        # all possible
        if m@(d,i) == 0 then (
          j := d+1;
          while j <= rows(m) do (
            if m@(j,i) == 0 then
              (j=j+1;continue);
            a := m@(j,);
            m@(j,) := m@(d,);
            m@(d,) := a;
            j := j+1;
            break
          )
        );
        if m@(d,i) == 0 then
          (i:=i+1;continue);

        # Here comes the actual zeroing of all but the anchor
        # element rows
        j := d+1;
        while j <= rows(m)) do (
          if m@(j,i) != 0 then (
            m@(j,) := m@(j,)-(m@(j,i)/m@(d,i))*m@(d,)
          );
          j := j+1
        );
        m@(d,) := m@(d,) * (1/m@(d,i));
        d := d+1;
        i := i+1
      );
      m
    )

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

### Cambiar la configuración con GEL

Muchas de las configuraciones en Genius son simplemente variables globales, y que se pueden evaluar y asignar de la misma manera que las variables normales. Consulte la sobre evaluar y asignar a variables, y la para una lista de configuraciones que se pueden modificar por este método.

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

    MaxDigits = 12

### Salida

Maximum digits to output

  El número máximo de dígitos en un resultado (`MaxDigits`)

Results as floats

  Indica si los resultados se imprimirán siempre como números flotantes (`ResultsAsFloats`)

Floats in scientific notation

  Indica si los números flotantes están en notación científica (`ScientificNotation`)

Always print full expressions

  Indica si se imprimen expresiones completas para valores de retorno no numéricos (más largos que una línea) (`FullExpressions`))

Use mixed fractions

  Indica si se imprimen las fracciones como fracciones mixtas utilizando la forma «1 1/3» en vez de «4/3». (`MixedFractions`)

Display 0.0 when floating point number is less than 10^-x (0=never chop)

  Indica cómo cortar la salida. Pero sólo cuando otros números pueden ser muy grandes. Consulte la documentación del parámetro `OutputChopExponent`.

Only chop numbers when another number is greater than 10^-x

  Indica cuándo se corta la salida. Esto lo configura el parámetro `OutputChopWhenExponent`. Consulte la documentación del parámetro `OutputChopExponent`.

Remember output settings across sessions

  Indica si la configuración de la salida en el campo Opciones de salida de número/expresión se recordarán para la próxima sesión. No se aplica al campo Opciones de salida de error/información.

  Si no está activada, se usará el valor predeterminado o cualquier configuración guardada anteriormente cada vez que se inicie Genius. Tenga en cuenta que las configuraciones se guardan al final de la sesión, así que si quiere cambiar los valores predeterminados, active esta casilla, reinicie herramienta matemática Genius y entonces desactive la casilla de nuevo.

Display errors in a dialog

  Si se activan, los errores se mostrarán en un diálogo separado, si no se activan, los errores se imprimirán en la consola.

Display information messages in a dialog

  Si se activan los mensajes de información se mostraran en un diálogo separado, si no se activan, los mensajes de información se imprimirán en la consola.

Maximum errors to display

  El número máximo de errores que devolver por una prueba (`MaxErrors`). Si lo establece a 0, entonces todos los errores se devolverán siempre . En general, si algún bucle causa muchos errores, entonces es poco probable que se de cuenta nada más que de unos pocos fallos, y verá una larga lista de fallos no sirve de mucha ayuda.

Además de estas preferencias, hay algunas preferencias que se pueden cambiar configurándolas en el área de trabajo de la consola. Para otras que puedan afectar a la salida consulte la .

`IntegerOutputBase`

  La base que se usará para mostrar enteros

`OutputStyle`

  Una cadena, puede ser `"normal"`, `"latex"`, `"mathml"` o `"troff"` y afectará a cómo se imprimen las matrices (y quizás otras cosas), útil para pegar en documentos. El estilo normal legible para los humanos,es el predeterminado por herramienta matemática Genius. Los otros estilos son para las tipografías de LaTeX, MathML (XML), o en Troff.

### Precisión

Floating point precision

  Indica la precisión en bits de los números en coma flotante (`FloatPrecision`). Tenga en cuenta que cambiar esto, sólo afecta a las cantidades calculadas más recientes. Los valores antiguos almacenados en variables, obviamente permanecerán en la precisión antigua y si quiere hacerlos más precisos, tendrá que volver a calcularlos. La excepción a esto son las constantes como `pi` o `e`.

Remember precision setting across sessions

  Indicar si la configuración de la precisión se recordará para la próxima sesión. Si no está activada, la configuración predeterminada o la configuración guardada anteriormente se utilizarán cada vez que Genius se inicie. Tenga en cuenta que las configuraciones se guardan al final de la sesión, así que si quiere cambiar la configuración por defecto, active esta casilla, reinicie Genius y luego vuelva a desactivarla.

### Terminal

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

Scrollback lines

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

Font

  La tipografía que usar en la terminal.

Black on white

  Si usar blanco sobre negro en la terminal.

Blinking cursor

  Cuando la terminal tenga el foco, el cursor parpadeará en ella. Puede que a veces resulte molesto y genere tráfico innecesario si ejecuta Genius remotamente.

### Memoria

Maximum number of nodes to allocate

  Internamente, todos los datos se ponen en pequeños nodos en la memoria. Esto da un límite máximo de nodos reservados para el procesado. Esto evita que se quede sin memoria si comete algún error que haga consumir al programa más memoria de lo normal, como podría ser una recursión sin fin. Esto podría ralentizar su máquina y complicar incluso la interrupción del programa.

  Una vez se ha alcanzado el límite, la herramienta matemática Genius preguntará si desea interrumpir el proceso o si desea continuar. Si decide continuar, no se aplicará ningún límite y será posible que su máquina se quede sin memoria. El límite se aplicará en la siguiente ocasión que ejecuté un programa o una expresión en la consola sin importar la respuesta a la pregunta.

  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

Jiří (George) Lebl (jirka@5z.com) ha desarrollado la Herramienta matemática Genius. La historia de la herramienta matemática Genius se remonta a 1997. Fue el primer programa calculadora de Gnome, sin embargo evolucionó a algo más que una calculadora de escritorio. Para más información acerca de la herramienta matemática Genius, por favor, visite la página web de Genius.

Para informar de un error o hacer una sugerencia sobre esta aplicación o sobre este manual, envíe un correo al autor o publique un mensaje en la lista de correo (consulte la página web).

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 3 ó (a su elección) cualquier versión posterior. Una copia de esta licencia puede encontrarse en link, o en el archivo COPYING incluido con el código fuente de este programa.

Jiří Lebl recibió apoyo parcial de la NSF grant DMS 0900885, DMS 1362337,y la Universidad de Illinois en Urbana-Champaign, la Universidad de California en San Diego, la Universidad de Wisconsin-Madison, y la Universidad del estado de Oklahoma durante el desarrollo del proyecto. El software se ha utilizado tanto para docencia como para investigación.