# Manual de Genius

## Introducción

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

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

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

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 mainwindow-fig.

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

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

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

Barra de menú.

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

  El menú Calculadora controla el motor de la calculadora. Permite ejecutar el programa actualmente seleccionado o interrumpir el cálculo actual. También puede mirar la expresión completa del último resultado (útil si el último resultado fue demasiado grande para ajustar a la consola), y puede mirar una lista con los valores de todas las variables definidas por el usuario. 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.

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

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

o

    genius> 62734 + 812634 + 77^4 mod 5

o

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

o

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

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

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

    genius> help

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

    genius> help nombre_de_la_función

Para ver este manual, escriba:

    genius> manual

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

    genius> load ruta/a/programa.gel

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

### Crear un programa nuevo

Si quiere insertar varios comando más complejos, o quizás escribir una función complicada utilizando el lenguaje GEL. Puede crear un nuevo programa.

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

### Trazado de líneas

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

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

#### Crear una ventana de dibujo

Muestra la ventana de trazado de líneas

En los cuadros de texto escriba sólo las expresiones donde `x` es la variable independiente. También puede dar simplemente nombres de funciones como `cos` en lugar de tener que escribir `cos(x)`. Puede crear gráficas de hasta 10 funciones. Si comete un error y Genius no puede analizar la entrada, se señalará con un icono de advertencia a la derecha del cuadro de texto donde ocurrió el error, y se mostrará un diálogo de error. Puede cambiar el rango de las variable dependiente `y` activando la casilla Ajustar al eje dependiente. Pulsando el botón Dibujar se generará el gráfico mostrado en la lineplot2-fig.

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

El gráfico producido.

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

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

### Gráficos paramétricos

En la ventana de crear dibujo, también puede elegir la pestaña Paramétrico para crear dibujos paramétricos bidimensionales. De este modo, puede dibujar una única función paramétrica. Puede especificar los puntos como `x` e `y`, o dar un número complejo único 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 paramplot-fig.

#### Pestaña dibujo paramétrico

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

Puede ver un ejemplo de una gráfica de una función paramétrica en la paramplot-fig. 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

Gráfico paramétrico producido

### Dibujos de campos de inclinación

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

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

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

### Gráficos de campos de vectores

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 surfaceplot-fig. 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

Valor absoluto de la función coseno complejo.

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

Los enteros son el primer tipo numérico en GEL. Los enteros se escriben de forma estándar.

    1234

Las formas hexadecimales y octales se pueden indicar mediante la notación de C. Por ejemplo:

    0x123ABC
    01234

O bien puede indicar los enteros en una base arbitraria usando `<base>\<número>`. Los dígitos mayores que 9 usan letras de manera similar a la forma hexadecimal. Por ejemplo, un número en base 23 podría escribirse:

    23\1234ABCD

El segundo tipo numérico de GEL son los racionales. Los números racionales se obtienen dividiendo dos enteros. De modo que se puede escribir:

    3/4

para obtener tres cuartos. Los racionales aceptan notación fraccionaria mixta. De modo que para obtener uno y tres décimos se podría indicar:

    1 3/10

El siguiente tipo numérico es el de coma flotante. Estos se especifican de un modo muy similar a la notación en C. Puedes usar `E`, `e` o `@` como el delimitador de exponente. Tenga en cuenta que usando el delimitador de exponente da un coma flotante incluso si no está la coma decimal en el número. Ejemplos:

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

Cuando Genius imprime un número en coma flotante siempre añade un `,0` incluso si el número está completo. Esto indica que los números en coma flotante se toman como cantidades imprecisas. Cuando un numero se escribe en notación científica, siempre será en coma flotante y, por tanto, Genius no imprime `,0`.

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

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

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

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

#### Booleanos

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

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

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

    ( (1 + true) - false ) * true

equivale a:

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

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

    1 == true

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

#### Cadenas

Al igual que los números y los booleanos, las cadenas en GEL se pueden almacenar como valores dentro de variables y pasárselas a funciones. Puede concatenar una cadena con otra cadena mediante el operador «+». Por ejemplo:

    a=2+3;«El resultado es: »+a

creará la cadena:

    El resultado es: 5

Puede usar secuencias de escape como en C tales como `\n`, `\t`, `\b`, `\a` y `\r`. Para insertar los caracteres `\` o `"` en una cadena puede escaparlo precediéndolo de `\`. Por ejemplo:

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

dará lugar a la cadena:

    Barra: \ Comillas: " Tabulaciones: 	1	2	3

. Tenga en cuenta, sin embargo, que cuando una función devuelve una cadena, los caracteres escapados se entrecomillan, por lo que la salida se puede usar como entrada de otra función. Si quiere imprimir la cadena como es (sin caracteres escapados), use las funciones `print` o `printn`.

Además, puede usar la función `string` de la biblioteca para convertir cualquier cosa en una cadena. Por ejemplo:

    string(22)

devolverá

    "22"

. Las cadenas pueden compararse mediante los operadores `==` (igual), `!=` (distinto) y `<=>` (comparación).

#### Nulo

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

Ejemplo:

    x=5;.
    x=5;

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

### Usar variables

Sintaxis:

    NombreVariable

Ejemplo:

    genius> e
    = 2.71828182846

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

#### Usar completado con el tabulador

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

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

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

#### Configurar variables

Sintaxis:

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

Ejemplo:

    x = 3
    x := 3

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

    a = b = 5

. Esto establecerá `b` a 5 y también `a` será 5.

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

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

#### Variables integradas

GEL 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 genius-gel-function-list-constants 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

Las variables `Ans` y `ans` se pueden usar para obtener el resultado de la última expresión utilizada. Por ejemplo, si acaba de realizar un cálculo y quiere añadirle 389 al resultado, podría hacer lo siguiente:

    Ans+389

### Usar funciones

Sintaxis:

    NombreFuncion(argumento1, argumento2, ...)

Ejemplo:

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

Para evaluar una funcion introduzca el nombre de ésta seguido de los argumentos (si si los hay) entre paréntesis. Esto devolverá el resultado de aplicar la función a sus argumentos. El número de argumentos es, por supuesto, diferente para cada función.

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 genius-gel-function-list para obtener una lista completa..

#### Usar completado con el tabulador

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

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

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

#### Definir funciones

Sintaxis:

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

El caracter ``` es el acento invertido y significa función anónima. Estableciéndoselo a una variable se define una función.

Una función toma cero o más argumentos separados por comas y devuelve el resultado del cuerpo de dicha función. Definir funciones propias es primordialmente una cuestión de conveniencia; un posible uso es tener un conjunto de funciones definidas en archivos GEL que Genius pueda cargar para tenerlas disponibles. Ejemplo:

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

por lo que `addup(1,4,9)` devuelve 14.

#### Listas de argumentos de variables

Si se incluye `...` después del último argumento en la declaración de una función Genius permitirá pasar a dicha función un número de argumentos arbitrario. Si no se pasa ningún argumento el último tendrá el valor `null`. De lo contrario, será un vector que contiene todos los argumentos. Por ejemplo:

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

Por tanto `f(1,2,3)` devuelve `[2,3]`, mientras que `f(1)` devuelve `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.

Si no se escriben los paréntesis después del nombre de la función, en lugar de evaluarse, la función se devolverá como un «nodo función». El nodo función se puede pasar a como argumento a otra función. Ejemplo:

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

Para pasar funciones que no están definidas se puede hacer uso de la función anónima (consulte la genius-gel-functions-defining). Es decir, cuando se quiere pasar una función sin dar un nombre. Sintaxis:

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

Ejemplo:

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

Devuelve 5.

#### Operaciones con funciones

Algunas funciones permiten operaciones aritméticas y algunos argumentos de función tales como `exp` o `ln`, para operar en la función. Por ejemplo,

    exp(sin*cos+4)

devolverá una función que toma `x` y devuelve `exp(sin(x)*cos(x)+4)`. Esta funcionalidad es equivalente a escribir

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

Esta operación puede ser útil cuando se definen funciones rápidamente. Por ejemplo, para crear una función llamada `f` que realice la operación arriba descrita, simplemente puede escribir:

    f = exp(sin*cos+4)

También se puede usar al dibujar. Por ejemplo, para dibujar el cuadrado de un seno puede utilizar:

    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 es más diferente que otros lenguajes a la hora de tratar con varios comandos y funciones. En GEL puede encadenar comandos junto con un operador de separación. Esto es, si quiere escribir más de una expresión utilice el operador `;` después de cada expresión. Esta es una forma en la que ambas expresiones se evaluan y se devuelve el resultado de la segunda expresión (o de la última, si hay más de dos expresiones). Suponga que escribe la siguiente expresión:

    3 ; 5

Esta expresión dará como resultado 5.

Esto requiere poner algunos paréntesis para evitar ambigüedades, especialmente si el carácter `;` no es la primitiva más prioritaria. Esto difiere ligeramente de otros lenguajes de programación donde el carácter `;` es un finalizador de sentencias. En GEL es un operador binario. Si está familiarizado con Pascal esto debería ser natural para usted. Sin embargo, Genius le permite simular que es un terminador si el carácter `;` se encuentra detrás de un paréntesis o un bloque, Genius añadirá automáticamente un nodo nulo como si hubiese escrito `;null`. Esto es útil en caso de que no quiera devolver ningún valor o si gestiona el retorno de un modo diferente. Tenga en cuenta que es ralentiza ligeramente el código si se ejecuta demasiado frecuentemente ya que se toma como un operador más.

Si escribe expresiones en un programa no tiene que añadir un punto y coma. En este caso Genius muestra el resultado de la expresión cuando se ejecuta. Sin embargo, si define una función, el cuerpo de la función es una sola expresión.

### Comentarios

GEL es similar a otros lenguajes de scripts en el sentido de que `#` indica un comentario, que es texto que no se evaluará. Todo lo que vaya después de la almohadilla hasta el final de la línea se ignorará. Por ejemplo,

    # Esto es un comentario
    # cada línea debe empezar por una almohadilla
    # en la siguiente línea se establece el valor de x a 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.

Dados dos números enteros a y b, puede calcular el inverso multiplicativo de a módulo b usando números racionales (desde luego, el inverso debe existir). Ejemplos:

    10^-1 mod 101
    1/10 mod 101

Puede obtener la evaluación modular de una matriz, calcular potencias, la matriz inversa y dividir. Ejemplo:

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

Es la matriz identidad, pues B es la matriz inversa de A módulo 5.

Algunas funciones como `sqrt` o `log` trabajan de una manera diferente en modo módulo. Éstas utilizarán sus versiones discretas trabajando en el entorno de enteros que el usuario ha seleccionado. Por ejemplo:

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

`sqrt` devolverá todas las raíces cuadradas posibles.

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 `a/b`.

`a.%b`

- Operador mod elemento por elemento. Devuelve el resto de `a./b` elemento por elemento.

`a mod b`

- Operación de evaluación modular. La expresión `a` se evalúa módulo `b`. Consulte la genius-gel-modular-evaluation. 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`

- Operador mayor o igual, 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 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».

`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ódico. 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 genius-gel-references.

`*a`

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

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

- Crea un vector con valores de `a` a `b` (o específica una región de filas o columnas para el operador `@`). Por ejemplo para obtener las filas 2 a 4 de la matriz `A` se podría hacer

      A@(2:4,)

  ya que `2:4` devolverá el vector `[2,3,4]`.

`a:b:c`

- Crea un vector con valores desde `a` a `c` usando `b` como paso. Por ejemplo:

      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`

- Crea un número imaginario (multiplicando `a` por el imaginario). Tenga en cuenta que normalmente el número`i` se escribe `1i`. De modo que lo descrito arriba es equivalente a

      (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

Sintaxis:

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

si se omite `else`, si la expresión `expression1` devuelve `false` o `0`, devolverá `NULL`.

Ejemplos:

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

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

    if a=5 then a=a-1

se interpretará como:

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

### Bucles

#### Bucles «while»

Sintaxis:

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

son similares a otros lenguajes. Sin embargo, puesto que GEL es una única expresión que debe devolver algo, estas construcciones devolverán el resultado de la última iteración o `NULL` si no se realiza ninguna operación. En la expresión booleana, `=` se traduce a `==` sólo para la sentencia `if`.

#### Bucles «for»

Sintaxis:

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

bucle en el que el identificador es un conjunto de todos los valores desde `<from>` hasta `<to>`, opcionalmente se puede usar un incremento distinto de 1. Dichos bucles son más rápidos, cómodos y compactos que los bucles normales descritos previamente pero menos flexibles. El identificador se debe tratar como tal y no se puede eliminar su referencia. El valor del identificador corresponde al último valor de éste o a `<from>` si el cuerpo del bucle no se ha evaluado todavía. Se garantiza que la variable permanezca inicializada tras el bucle, de modo que puede usarla sin problemas. Además, `<from>`, `<to>` e `<increment>` no pueden ser valores complejos. Tampoco se garantiza que se alcance `<to>`, pero sí que nunca se rebasará. El ejemplo siguiente imprime todos los números pares desde 1 a 19:

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

Cuando uno de los valores es un número de coma flotante, la verificación final se realiza con un paso de de 2 ^ -20. Es decir, incluso si se sobrestima 2 ^ -20 veces el «por» por encima, todavía se ejecuta la última iteración. De este modo

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

hace lo esperado aunque sumar 0,1 diez veces es algo superior a 1,0 debido a la forma en que los números de coma flotante se almacenan en la base 2 (no hay 0,1, el número real almacenado es sólo ligeramente más grande). Esto no es perfecto, pero funciona en la mayoría de los casos. Si quiere evitar este problema, utilice reales números racionales, por ejemplo:

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

Esta comprobación se realiza únicamente desde la versión 1.0.16 en adelante, por lo que la ejecución del código puede variar en versiones anteriores.

#### Bucles «foreach»

Sintaxis:

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

ejecuta el cuerpo del bucle para cada uno de los elementos de la matriz recorriendo ésta fila por fila y de izquierda a derecha. Para imprimir los números 1, 2, 3 y 4 en este orden se podría hacer lo siguiente:

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

Si desea recorrer las filas y columnas de una matriz puede usar las funciones RowsOf y ColumnsOf que devuelven un vector de filas o columnas de la matriz. Por lo tanto,

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

imprimirá `[1,2]` y después `[3,4]`.

#### Parar y continuar

También puede utilizar los comandos `break` y `continue` en un bucle. El comando `continue` reinicia el bucle actual en la siguiente iteración, mientras que el comando `break` sale del bucle actual.

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

### Sumas y productos

Sintaxis:

    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>

Si sustituye `for` por `sum` o `prod`, obtendrá una suma o un producto en lugar de un bucle `for`. En vez de el último valor del bucle, devolverá la suma o el producto de todos los valores obtenidos respectivamente.

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 genius-gel-loops-for.

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

Generalmente `=` se traduce como `==` si aparece en algún lugar dónde GEL espera una condición, como la condición «if». Por ejemplo

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

son lo mismo en GEL. Sin embargo, debería utilizar `==` o `:=` cuando se quiere comparar o asignar, respectivamente, si quiere que su código sea fácil de leer. Además le ayuda a evitar errores.

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.

Al igual que la mayoría de los lenguajes de programación, GEL tiene diferentes tipos de variables. Normalmente, cuando se define una variable en una función ésta es visible desde esa función y desde todas las funciones que se llamen (todos los contextos superiores). Por ejemplo, suponga que una función `f` define una variable `a` y luego llama a otra función `g`. Entonces, la función `g` puede hacer referencia a la variable `a`. Pero, una vez que la ejecución de `f` concluye, la variable `a` sale del ámbito. Por ejemplo, el siguiente código imprime el número 5. No se puede llamar a la función `g` desde el nivel más alto (fuera de `f`, dado que `a` no se habrá definido).

Si define una variable dentro de una función, ésta anulará toda variable definida al llamar a funciones. Por ejemplo, si modifica el código anterior y escribe:

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

Este código aún imprime 5. Pero si llama a la función `g` fuera de `f`, entonces se imprimirá 10. Observe que al definir `a` como 5 dentro de `f` no cambia el valor de `a` al nivel superior (global), por lo que si verifica el valor de `a` es aún 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.

Las funciones se tratan exactamente como variables. Por lo tanto, puede redefinir funciones. Normalmente, (en el nivel superior) no puede redefinir variables y funciones protegidas. Pero localmente si lo puede hacer. Considere la siguiente sesión:

    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

Las funciones definidas en el nivel superior se consideran globales. Éstas son visibles desde cualquier parte. Como se dijo, la función `f` no cambiará el valor de `a` a 5.

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

Sin embargo, en algunas ocasiones es necesario fijar una variable global dentro de una función. Cuando este comportamiento es necesario, utilice la función `set`. Si introduce una cadena o un identificador entrecomillado a esta función, ésta fija la variable globalmente (al nivel superior). Por ejemplo, podría utilizar

    set(`a,3)

o

    set("a",3)

para fijar el valor 3 en la variable `a`.

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

Como se dijo, existen variables especiales llamadas parámetros. Éstas existen en todos los ámbitos. Para declarar un parámetro llamado `foo` con valor inicial 1, escriba

    parameter foo = 1

A partir de ahí, `foo` es una variable estrictamente global. Si asigna un valor a `foo` dentro de cualquier función, modificará la variable en todos los contextos. Esto significa que las funciones no tienen una copia privada de los parámetros.

Cuando define un parámetro utilizando la función `undefine`, éste deja de ser un parámetro.

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

Ejemplo:

    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.

Cuando se utilizan funciones que devuelven valores a través de referencias en la lista de argumentos, pase solo el nombre de la variable con un ampersand (&). Por ejemplo, el siguiente código calcula el valor propio de una matriz `A` con un vector propio inicial indeterminado `x`, y guarda el vector propio obtenido en la variable `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.

Las referencias se pueden explicar mejor utilizando un ejemplo:

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

ahora `a` contiene el valor 2. También puede hacer referencia a funciones:

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

devuelve el valor 4.

### Lvalues

Un lvalue es el lado izquierdo the una asignación. En otras palabras, un lvalor es lo que se le asigna a algo. Algunos lvalues válidos son:

`a`

- Identificador. Aquí se asignará la variable de nombre `a`.

`*a`

- Eliminar la referencia a un identificador. Esto fijará lo que a lo que apunta la variable `a`.

`a@(<region>)`

- Región de una matriz. Aquí, la región normalmente se especifica como con el operador regular @(), y puede ser un sola entrada, o una región completa de una matriz.

Ejemplos:

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

Tenga en cuenta que tanto `:=` como `=` pueden utilizarse indistintamente, salvo que la asignación aparezca en una condición. Es por esto que siempre es mas seguro sólo utilizar `:=` cuando se pretenda establecer una asignación y `==` para hacer una comparación.

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

Por ejemplo, si quiere verificar argumentos en una función. Podría utilizar el siguiente código:

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

### Sintaxis de nivel superior

Cuando se indroduce una sentencia en el nivel más alto, la sintaxis es distinta a la que se utiliza cuando se introduce entre paréntesis o dentro de una función. En el nivel más alto la tecla «Intro» tiene el mismo efecto que al pulsarla en la línea de comandos. Piense en un programa como una secuencia de líneas introducidas en la línea de comandos. En particular, no necesita introducir el separador al final de la línea (salvo que sea parte de varias sentencias dentro de paréntesis).

El siguiente código, aunque funcione bien en la función, puede producir un error al introducirlo en el nivel más alto de un programa.

    if Algo() then
      HacerAlgo()
    else
      HacerOtraCosa()

El problema es que, después que la Herramienta Matemática Genius ve el caracter de final de línea después de la segunda línea, la aplicación decidirá que ya se a completado la sentencia y la ejecutará. Cuando se termine la ejecución, la Herramienta Matemática Genius continuará con la siguiente línea y producirá un error al leer la sentencia `else`. Utilice paréntesis para evitar esto. La Herramienta Matemática Genius no estará satisfecha hasta que todos los paréntesis estén cerrados.

    if Algo() then (
      HacerAlgo()
    ) else (
      HacerOtraCosa()
    )

### Devolver funciones

Es posible devolver funciones como un valor. De esta manera puede construir funciones que construyan otras funciones con propósitos específicos de acuerdo a ciertos parámetros. La parte complicada es determinar qué variables ve la función. La manera en que esto funciona en GEL es la siguiente: cuando una función devuelve otra función, todos los identificadores que referencia el cuerpo de la función que sale del ámbito son antepuestos al diccionario privado de la función devuelta. Por lo tanto, la función verá todas las variables que estaban en el ámbito cuando fue definida. Por ejemplo, la siguiente función devuelve una función que agrega 5 al valor de su argumento:

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

Tenga en cuenta que la función agrega `k` a `x`. Podría utilizar esto como sigue:

    g = f();
    g(5)

And `g(5)` devuelve el valor 10.

Algo que conviene tener en cuenta es que el valor de `k` que se utiliza es el que se encuentra activo mientras `f` devuelve su valor. Por ejemplo:

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

devolverá una función que añade 10 a su argumento, en lugar de 5. Esto es porque el diccionario adicional se crea sólo cuando el contexto en el que la función se define termina, que es cuando la función `f` devuelve su valor. Esto es consistente con cómo que esperaría que la función `r` actuara dentro de la función `f` según las reglas sobre el ámbito de variables en GEL. Al diccionario adicional sólo se añaden las variables que se utilizaron en contextos que recién terminan y que ya no existen. Las variables que se utilizan en la función que están en contextos que se mantienen válidos funcionan de manera usual, utilizan el valor actual de la variable. La única diferencia es entre las variables globales y las funciones. Todos los identificadores que hacen referencia a variables globales al momento de definir la función no se agregan al diccionario privado. Esto es para evitar trabajo innecesario al devolver una función y rara vez será un problema. Por ejemplo, suponga que borra «k=5» de la función `f` y que, en el nivel más alto, define `k` como 5, por ejemplo. Cuado ejecute la función `f`, la función `r` no añadirá `k` al diccionario privado pues ésta es una variable global (del nivel más alto) en el momento en que se definió `r`.

Algunas veces es mejor tener más control sobre cómo las variables se copian al diccionario privado. Desde la versión 1.0.7 puede especificar qué variables se copian al diccionario privado colocando corchetes adicionales después de los argumentos con la lista de variables que se desean copiar separadas con comas. Si hace esto, las variables se copiarán al diccionario privado en el momento que se define la función, y no se tocará el diccionario privado después de esto. Por ejemplo,

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

devuelve una función que cuando se llama añade 5 a su argumento. La copia local de `k` se crea cuando la función se define.

Cuando quiera que la función no tenga un diccionario privado escriba un par de corchetes vacíos después de la lista de argumentos. Con esto no se creará ningún diccionario privado. Hacer esto es útil para incrementar la eficiencia cuando no se necesita un diccionario privado o cuando quiere que la función busque todas las variables cuando las ve al momento que se la llama. Por ejemplo, suponga que quiere que la función que devuelve `f` ve el valor de `k` del nivel más alto sin importar que hay una variable con el mismo nombre al momento de la definición. El código

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

devuelve 20 y no 15, lo que podría suceder si se hubiese añadido `k` con valor 5 al diccionario privado.

### Variables locales verdaderas

Cuando se pasa una función a otras funciones, la manera predeterminada en que se determinan los ámbitos de las variables puede no ser la que quiere. Por ejemplo:

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

probablemente quiere que la función `r`, en el momento que pasa como `g` a la función `f`, vea la variable `k` como 10 y no 5 y que el código devuelva 11 y no 6. Sin embargo, como está escrita, la función verá `k` con el valor 5. Existen dos maneras de resolver este problema. Una es hacer que `r` guarde `k` en un diccionario privado utilizando la notación de corchetes. Consulte la sección Devolver funciones.

Pero hay otra solución. Desde la versión 1.0.7 existen variables locales verdaderas. Éstas son variables que son visibles sólo desde el contexto actual y no desde ninguna función que se llame. Se podría definir `k` como una variable local en la función `f`. Para hacer esto, añada la sentencia `local` como la primera sentencia en la función (siempre debe de ser la primera sentencia de la función). También puede convertir cualquier argumento en una variable local. Esto es,

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

El código funcionará como se espera e imprimirá 11. Observe que la sentencia `local` inicializa todas las variables que se referencian (salvo los argumentos de funciones) como una constante `null`.

Si todas las variables se crean localmente, puede pasar un asterisco en lugar de una lista de variables. En este caso las variables no se inicializarán hasta que se fijen, desde luego. Entonces, la siguiente definición de `f` también funcionará:

    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

Algunas veces tiene un programa más largo que escribió en un archivo y quiere leer dicho archivo con la herramienta matemática Genius. En estas situaciones tiene dos opciones. Puede conservar las funciones que más usa en el archivo `~/.geniusinit`. Si quiere cargar un archivo a la mitad de una sesión (o desde otro archivo), puede escribir `load <list of filenames>` en la línea de comandos. Esto se tiene que hacer desde el nivel más alto y no dentro de alguna función a algo similar, y no puede ser parte de una expresión. También tiene una sintaxis ligeramente distinta que el resto de Genius, similar a la que se usa en la consola. Puede escribir el nombre del archivo entre comillas. Si utiliza las comillas '' obtendrá exactamente la cadena que escriba, si utiliza las comillas "" no se escaparán los caracteres especiales como se hace con las cadenas. Ejemplo:

    load programa1.gel programa2.gel
    load "Nombre raro de archivo con ESPACIOS.gel"

Los comandos `cd`, `pwd` y `ls` también están incluídos. El comando `cd` toma un argumento, `ls` toma una argumento que es como «glob» en la consola de Unix (puede utilizar comodines, por ejemplo). El comando `pwd` no toma ningún argumento. Por ejemplo:

    cd «carpeta_con_programas_gel»
    ls *.gel

## Matrices en GEL

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

### Introducir matrices

Para introducir matrices, puede utilizar cualquiera de las dos sintaxis que siguen. Puede introducir la matriz en una línea, separando los valores con comas y las filas con un punto y coma. También puede introducir cada fila en una línea, separando los valores con comas. También puede combinar los dos métodos. Para introducir una matriz de 3x3 con los números 1 a 9 podría hacer lo siguiente:

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

o

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

No utilice «;» y «return» en la misma línea.

También puede utilizar la funcionalidad de expandir matrices para introducir una matriz. Por ejemplo puede hacer lo siguiente:

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

y obtendrá

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

Puede construir matrices con vectores y cosas parecidas de manera similar.

Otra cosa es que se los puntos no especificados se inicialicen a 0, por lo que

    [1, 2, 3
     4, 5
     6]

será

    [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

Puede calcular la matriz traspuesta conjugada de una matriz utilizando el operador `'`. Es decir, la entrada correspondiente al renglón `j` y la columna `i` será el complejo conjugado de la entrada correspondiente a la fila `i` y la columna `j` de la matriz original. Por ejemplo:

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

Se traspone el segundo vector para que sea posible multiplicar las matrices. Si solamente quiere trasponer la matriz sin conjugarla, utilice el operador `.'`. Por ejemplo:

    [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

Actualmente, los polinomios de una variable son vectores horizontales con valores como nodos. La potencia del término es la posición en el vector, con la primera posición siendo 0. Por lo tanto,

    [1,2,3]

se traduce en un polinomio como

    1 + 2*x + 3*x^2

Se pueden sumar, restar y multiplicar polinomios utilizando las funciones `AddPoly`, `SubtractPoly` y `MultiplyPoly` respectivamente. Se puede imprimir un polinomio utilizando la función `PolyToString`. Por ejemplo,

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

devuelve

    3*y^2 + 2*y + 1

También se puede obtener una representación funcional del polinomio de manera que puede evaluarse. Esto se realiza utilizando `PolyToFunction`, que devuelve una función anónima.

    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 genius-gel-function-list-polynomials 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.

Para construir un conjunto fuera de un vector, use la función `MakeSet`.Actualmente, sólo se devolverá un nuevo vector donde cada elemento es único.

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

Del mismo modo hay funciones que se explican por si mismas como `Union`, `Intersection`, `SetMinus`. Por ejemplo:

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

. Tenga en cuenta que no se garantiza el orden en los valores que devuelve la función. Si se quiere ordenar el vector puede usar la función `SortVector`.

Para los miembros del equipo de pruebas, hay funciones `IsIn` y `IsSubset`, que devuelven un valor tipo «bool». Por ejemplo:

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

La entrada `IsIn(x,X)` por supuesto es equivalente a `IsSubset([x],X)`. Obsérvese que puesto que el conjunto vacío es un subconjunto de cada conjunto, `IsSubset(null,X)` es siempre «true».

## Lista de funciones GEL

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

    help NombreFuncion

### Comandos

help

-     help

      ayuda NombreFunción

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

load

-     load «archivo.gel»

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

cd

-     cd /carpeta/nombre

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

pwd

-     pwd

  Imprimir la carpeta de trabajo actual.

ls

-     ls

  Listar archivos en la carpeta actual.

plugin

-     plugin nombre_del_complemento

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

### Básico

AskButtons

-     AskButtons (consulta)

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

  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)

  Compone y ejecuta una funcion con ella misma `n` veces, pasando `x` como argumento. Devolviendo `x` si `n` es cero. Por ejemplo:

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

  Muestra la configuración de variables. Las variables pueden ser cadenas o identificadores. Por ejemplo:

      DisplayVariables(`x,`y,`z)

  Si se llama sin argumentos (debería suministrar una lista vacía de argumentos) como

      DisplayVariables()

  entonces todas las variables se imprimirán incluyendo una lista de llamadas similar a Muestra variables del usuario en la versión gráfica.

  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

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

  Imprime una tabla de valores para una función. Los valores están en el vector `v`. Puede usar la notación de construcción de vectores como sigue:

      PrintTable (f,[0:10])

  Si `v` es un entero positivo, se utilizarán todos los elementos de la tabla de enteros desde 1 hasta v incluido.

  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)

  Establecer una variable global. La variable `id` sólo puede ser una cadena o un identificador. Por ejemplo:

      set(`x,1)

  establecerá la variable global `x` a 1.

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

SetElement

-     SetElement (id,row,col,val)

  Establecer un elemento de una variable global, que es una matriz. La variable `id` puede ser una cadena o un identificador entrecomillado. Por ejemplo:

      SetElement(`x,2,3,1)

  establecerá el elemento de la segunda fila, tercera columna de la variable global `x` a 1. Si no existe el nombre de la variable global, o si se configura algo que no es una matriz, se creará una nueva matriz con el tamaño apropiado rellena con ceros.

  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)

  Establecer un elemento de una variable global, que es un vector. La variable `id` puede ser una cadena o un identificador entrecommillado. Por ejemplo:

      SetElement(`x,2,1)

  establecerá el segundo elemento del vector variable global `x` a 1. Si no existe el nombre de la variable global, o si está configurado para algo distinto que no sea un vector (matriz), se creará una nueva fila del vector con valor cero y con el tamaño apropiado.

  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

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

  Esto afecta principalmente a cómo las matrices y fracciones se imprimen y es útil para pegar en los documentos. Por ejemplo, puede configurarlo en LaTeX usando:

      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)

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

  Obtener el menor número entero mayor o igual a `n`. Ejemplos:

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

  Alias: `Max` `Maximum`

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

min

-     min (a,args...)

  Alias: `Min` `Minimum`

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

rand

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

  Generar número enteros aleatorios en el rango `[0,máx)`. Si se indica «tamaño», entonces devuelve una matriz (si se especifican dos números) o un vector (si se especifica un número). Por ejemplo,

      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`

  La raíz cuadrada. Cuando se opera con «módulo», algunos enteros devolverán un valor `null` o un vector de raíces cuadradas. Ejemplos:

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

  Consulte Planetmath para obtener más información.

trunc

-     trunc (x)

  Alias: `Truncate` `IntegerPart`

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

### Trigonometría

acos

-     acos (x)

  Alias: `arccos`

  La función arccos (inversa del cos).

acosh

-     acosh (x)

  Alias: `arccosh`

  La función arccosh (inversa del cosh).

acot

-     acot (x)

  Alias: `arccot`

  La función arccot (inversa de la cot)

acoth

-     acoth (x)

  Alias: `arccoth`

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

acsc

-     acsc (x)

  Alias: `arccsc`

  La inversa de la función cosecante.

acsch

-     acsch (x)

  Alias: `arccsch`

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

asec

-     asec (x)

  Alias: `arcsec`

  La inversa de la función secante.

asech

-     asech (x)

  Alias: `arcsech`

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

asin

-     asin (x)

  Alias: `arcsin`

  La función arcsen (inversa del sen).

asinh

-     asinh (x)

  Alias: `arcsinh`

  La función arcsenh (inversa del senh).

atan

-     atan (x)

  Alias: `arctan`

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

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

atanh

-     atanh (x)

  Alias: `arctanh`

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

atan2

-     atan2 (y, x)

  Alias: `arctan2`

  Calcula la función «arctan2». Si `x>0`, entonces devuelve `atan(y/x)`. Si `x<0`, entonces devuelve `sign(y) * (pi - atan(|y/x|)`. Cuando `x=0`, devuelve `sign(y) * pi/2`. `atan2(0,0)` devuelve 0 en lugar de fallar.

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

cos

-     cos (x)

  Calcula la función coseno.

  Consulte Planetmath para obtener más información.

cosh

-     cosh (x)

  Calcula la función coseno hiperbólico.

  Consulte Planetmath para obtener más información.

cot

-     cot (x)

  La función cotangente.

  Consulte Planetmath para obtener más información.

coth

-     coth (x)

  La función cotangente hiperbólica.

  Consulte Planetmath para obtener más información.

csc

-     csc (x)

  La función cosecante.

  Consulte Planetmath para obtener más información.

csch

-     csch (x)

  La función cosecante hiperbólica.

  Consulte Planetmath para obtener más información.

sec

-     sec (x)

  La función secante.

  Consulte Planetmath para obtener más información.

sech

-     sech (x)

  La función secante hiperbólica.

  Consulte Planetmath para obtener más información.

sin

-     sin (x)

  Calcula la función seno.

  Consulte Planetmath para obtener más información.

sinh

-     sinh (x)

  Calcula la función seno hiperbólico.

  Consulte Planetmath para obtener más información.

tan

-     tan (x)

  Calcula la función tangente.

  Consulte Planetmath para obtener más información.

tanh

-     tanh (x)

  La función tangente hiperbólica.

  Consulte Planetmath para obtener más información.

### Teoría de números

AreRelativelyPrime

-     AreRelativelyPrime (a,b)

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

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

BernoulliNumber

-     BernoulliNumber (n)

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

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

ChineseRemainder

-     ChineseRemainder (a,m)

  Alias: `CRT`

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

ExactDivision

-     ExactDivision (n,d)

  Devuelve `n/d` pero solo si `d` es divisible entre `n`. Si `d` no es divisible entre `n` entonces esta función devuelve basura. Esto es mucho mas rápido para números muy grandes que la operación `n/d`, pero sólo es útil si se sabe que la división es exacta.

Factorize

-     Factorize (n)

  Devuelve la factorización de un número como una matriz. La primera fila son los números primos en la factorización (incluido el 1) y la segunda fila son las potencias. Por ejemplo:

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

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

Factors

-     Factors (n)

  Devuelve todos los factores de `n` en un vector. Esto incluye todos los factores no primos como buenos. Incluye 1 y el mismo número. Así por ejemplo, para imprimir todos los números perfectos (aquellos que son sumas de sus factores) hasta el número 1000 (esto es muy ineficiente) haga

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

  Comprobar si un entero es un cuadrado perfecto de un entero. El número será un entero real. Los enteros negativos, por supuesto, no son perfectos cuadrados de enteros reales.

IsPrime

-     IsPrime (n)

  Comprueba si dos números enteros son primos, para números menores que 2.5e10 la respuesta es determinista (si la hipótesis de Riemann es verdadera). Para números más grandes, la probabilidad de un falso positivo depende de `IsPrimeMillerRabinReps`. Significa que la probabilidad de un falso positivo es 1/4 de la potencia `IsPrimeMillerRabinReps`. De manera predeterminada el valor de 22 produce una probabilidad entorno a 5.7e-14.

  Si se devuelve `false`, puede estar seguro de que el número es un compuesto. Si quiere estar totalmente seguro de que tiene un número primo use `MillerRabinTestSure` pero esto le puede llevar mucho más tiempo.

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

LucasNumber

-     LucasNumber (n)

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

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

MaximalPrimePowerFactors

-     MaximalPrimePowerFactors (n)

  Devuelve todos los factores primos de un número.

MersennePrimeExponents

-     MersennePrimeExponents

  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 GIMPSpara obtener más información.

MillerRabinTest

-     MillerRabinTest (n,reps)

  Utiliza la prueba de números primarios Miller-Rabin de `n`, `reps` número de veces. La probabilidad de falso positivo es `(1/4)^reps`. Probablemente es mejor usar `IsPrime` ya que es más rápido y mejor sobre enteros más pequeños.

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

ModInvert

-     ModInvert (n,m)

  Devuelve el inverso de n módulo m.

  Consulte Mathworld para obtener más información.

MoebiusMu

-     MoebiusMu (n)

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

PseudoprimeTest

-     PseudoprimeTest (n,b)

  Prueba de pseudo-primo, devuelve `true` sólo si `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 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 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 Planetmath o Mathworld para obtener más información.

### Manipulación de matrices

ApplyOverMatrix

-     ApplyOverMatrix (a,func)

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

ApplyOverMatrix2

-     ApplyOverMatrix2 (a,b,func)

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

ColumnsOf

-     ColumnsOf (M)

  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.

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

  Hacer un vector columna fuera de la matriz colocando columnas una encima de la otra. Devuelve `null` cuando se introduce `null`.

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)

  Obtiene las filas de una matriz como un vector vertical. Cada elemento del vector es un vector horizontal que se corresponde con la fila de `M`. Esta función es útil si se quiere recorrer las filas de una matriz. Por ejemplo, como en `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 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 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`.

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

DeterminantalDivisorsInteger

-     DeterminantalDivisorsInteger (M)

  Obtiene determinantes divisores de una matriz de enteros (no su característica).

DirectSum

-     DirectSum (M,N...)

  Suma directa de matrices.

DirectSumMatrixVector

-     DirectSumMatrixVector (v)

  Suma directa de un vector de matrices.

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

Eigenvectors

-     Eigenvectors (M)

      Eigenvectors (M, &eigenvalues)

      Eigenvectors (M, &eigenvalues, &multiplicities)

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

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

GramSchmidt

-     GramSchmidt (v,B...)

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

HankelMatrix

-     HankelMatrix (c,r)

  Hankel matrix.

HilbertMatrix

-     HilbertMatrix (n)

  Matriz de Hilbert de orden `n`.

  Consulte Planetmath para obtener más información.

Image

-     Image (T)

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

InfNorm

-     InfNorm (v)

  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 (no su característica).

InverseHilbertMatrix

-     InverseHilbertMatrix (n)

  Matriz inversa de Hilbert de orden `n`.

  Consulte Planetmath para obtener más información.

IsHermitian

-     IsHermitian (M)

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

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

  Obtener la descomposición de LU de `A` es decir, encontrar una matriz triangular inferior y la matriz triangular superior cuyo producto es `A`. Guarda el resultado en `L` y `U` que son referencias. Devuelve `true` si se completó con éxito. Por ejemplo, suponga que «A» es una matriz cuadrada, entonces después ejecute:

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

  tendrá la matriz inferior guardada en una variable llamada `L` y la matriz superior en una variable llamada `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)

  Obtener la descomposición QR de una matriz cuadrada `A`, devuelve la matriz triangular superior `R` y establece `Q` a la matriz ortogonal (unitaria). `Q` será una referencia o `null` si no quiere que se devuelva ningún valor. Por ejemplo:

      genius> R = QRDecomposition(A,&Q)

  tendrá la matriz triangular superior guardada en una variable llamada `R` y la matriz ortogonal (unitaria) guardada en `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 (no su característica).

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

  Devuelve la matriz de Toeplitz que se construye con la primera columna «c» y (opcionalmente) la primera fila «r». Si sólo se da la columna «c», entonces esta es conjugada y la versión no conjugada la utiliza la primera fila para dar una matriz Hermitiana (si el primer elemento es 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)

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

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

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

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 pequeño 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 Mathworld para obtener más información.

GaloisMatrix

-     GaloisMatrix (regla_de_combinación)

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

GreedyAlgorithm

-     FrobeniusNumber (n,v)

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

HarmonicNumber

-     HarmonicNumber (n,r)

  Alias: `HarmonicH`

  Número harmónico, el `n`-ésimo número harmónico de orden `r`.

Hofstadter

-     Hofstadter (n)

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

LinearRecursiveSequence

-     LinearRecursiveSequence (seed_values,combining_rule,n)

  Calcular la 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.

  La fórmula para `Multinomial(a,b,c)` se puede escribir como:

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

  . En otras palabras, si sólo hay dos elementos, entonces `Multinomial(a,b)` es lo mismo que `Binomial(a+b,a)` o `Binomial(a+b,b)`.

  Consulte Planetmath, Mathworld, o la Wikipedia 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.

  Por ejemplo, con Combination normalmente escribiría un bucle como sigue:

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

  Pero con NextCombination escribiría algo como lo siguiente:

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

  Consulte también Combination.

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=1}^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.

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.

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)

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

  Nú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 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 Planetmath para obtener más información.

MoebiusMapping

-     MoebiusMapping (z,z2,z3,z4)

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

  Consulte Planetmath para obtener más información.

MoebiusMappingInftyToInfty

-     MoebiusMappingInftyToInfty (z,z2,z3)

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

  Consulte Planetmath para obtener más información.

MoebiusMappingInftyToOne

-     MoebiusMappingInftyToOne (z,z3,z4)

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

  Consulte Planetmath para obtener más información.

MoebiusMappingInftyToZero

-     MoebiusMappingInftyToZero (z,z2,z4)

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

  Consulte Planetmath para obtener más información.

PoissonKernel

-     PoissonKernel (r,sigma)

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

PoissonKernelRadius

-     PoissonKernelRadius (r,sigma)

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

RiemannZeta

-     RiemannZeta (x)

  Alias: `zeta`

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

  Consulte Planetmath 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 la 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.

  Ejemplo:

      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.

  La salida para un sistema es todavía una matriz de n por 2 siendo la segunda entrada un vector. Si quiere dibujar la línea, asegúrese de utilizar fila de vectores, y aplanar la matriz con ExpandMatrix, y pulse sobre las columnas de la derecha. Ejemplo:

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

  Ejemplo para encontrar la raíz cuadrada de 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`.

  Ejemplo para encontrar la raíz cuadrade de 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 o Mathworld 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 la 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 la 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.

  La salida de un sistema todavía es una matriz de n por 2 siendo la segunda entrada un vector. Si quiere dibujar la línea, asegúrese de utilizar filas de vectores, y aplane la matriz con ExpandMatrix, y pulse a la derecha de las columnas. Ejemplo:

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

  Desde la versión 1.0.10 en adelante.

### Estadísticas

Average

-     Average (m)

  Alias: `average` `Mean` `mean`

  Calcular la media de una matriz entera.

  Consulte Mathworld para obtener más información.

GaussDistribution

-     GaussDistribution (x,sigma)

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

  Consulte Mathworld para obtener más información.

GaussFunction

-     GaussFunction (x,sigma)

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

  Consulte Mathworld para obtener más información.

Median

-     Median (m)

  Alias: `median`

  Calcular la mediana de una matriz entera.

  Consulte 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 columna de una matriz.

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

  Ejemplo para encontrar la raíz cuadrada de 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)

  Convertir un vector de valores ASCII en una cadena.

AlphabetToString

-     AlphabetToString (vec,alfabeto)

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

StringToASCII

-     StringToASCII (cad)

  Convertir una cadena a un vector de valores ASCII.

StringToAlphabet

-     StringToAlphabet (str,alfabeto)

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

### Operaciones simbólicas

SymbolicDerivative

-     SymbolicDerivative (f)

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

  Ejemplos:

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

SymbolicDerivativeTry

-     SymbolicDerivativeTry (f)

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

SymbolicNthDerivative

-     SymbolicNthDerivative (f,n)

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

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

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.

  Ejemplos:

      genius> ExportPlot("archivo.png")
      genius> ExportPlot("/carpeta/archivo","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.

  Ejemplos:

      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.

LinePlotDrawLine

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

      LinePlotDrawLine (v,...)

  Dibuja una línea desde `x1`,`y1` hasta `x2`,`y2`. Es posible reemplazar `x1`,`y1`, `x2`,`y2` por una matriz de `n` por 2 para obtener una curva poligonal de mayor longitud.

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

  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.

  Ejemplos:

      genius> LinePlotDrawLine(0,0,1,1,"color","blue","thickness",3)
      genius> LinePlotDrawLine([0,0;1,-1;-1,-1])
      genius> LinePlotDrawLine([0,0;1,1],"arrow","end")
      genius> LinePlotDrawLine(RungeKuttaFull(`(x,y)=y,0,3,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])

LinePlotDrawPoints

-     LinePlotDrawPoints (x,y,...)

      LinePlotDrawPoints (v,...)

  Dibuja un punto en `x`,`y`. La entrada puede ser una variable `n` una matriz de 2 `n` puntos diferentes. Esta función es esencialmente la misma entrada que LinePlotDrawLine.

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

  Ejemplos:

      genius> LinePlotDrawPoints(0,0,"color","blue","thickness",3)
      genius> LinePlotDrawPoints([0,0;1,-1;-1,-1])
      genius> LinePlotDrawPoints(RungeKuttaFull(`(x,y)=y,0,3,100),"color","blue","legend","The Solution")

  Disponible desde la versión 1.0.18 en adelante.

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.

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.

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

  Ejemplos:

      genius> Slopefield(`(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.

  Ejemplos:

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

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.

  Ejemplos:

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

  Esto es un ejemplo de cómo dibujar con coordenadas polares, en particular, cómo dibujar la función `-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.

  Ejemplos:

      genius> SurfacePlotDataGrid([1,2;3,4],[0,1,0,1])
      genius> SurfacePlotDataGrid(data,[-1,1,-1,1],"Mis datos")
      genius> d:=null; for i=1 to 20 do for j=1 to 10 d@(i,j) = (0.1*i-1)^2-(0.1*j)^2;
      genius> SurfacePlotDataGrid(d,[-1,1,0,1],"media silla de montar")

  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, flechas, 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.

  Ejemplos:

      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.

  Ejemplos:

      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.

  Ejemplos:

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

## Programas de ejemplo en GEL

Esto es una función que calcula factoriales:

    function f(x) = if x <= 1 then 1 else (f(x-1)*x)

Con sangría se convierte:

    function f(x) = (
      if x <= 1 then
        1
      else
        (f(x-1)*x)
    )

Esto es un puerto directo de la función factorial desde la página principal bc. La sintaxis es similar a bc, pero diferente en que en GEL, la última expresión es la única que se devuelve. Utilizar la función `return` en su lugar, esto será:

    function f(x) = (
      if (x <= 1) then return (1);
      return (f(x-1) * x)
    )

Con mucho, la manera más fácil de definir una función factorial será usar el lazo del producto como sigue. No es sólo la manera más corta y más rápida, sino probablemente la versión mas legible.

    function f(x) = prod k=1 to x do k

He aquí un ejemplo más extenso, esto básicamente redefine la función interna `ref` para calcular la fila escalar de una matriz. La función `ref` se construye de manera mucho más rápida, pero este ejemplo demuestra algunas de las características más complejas de 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

Para configurar la herramienta matemática Genius, elija Configuración Preferencias. Hay varios parámetros básicos proporcionados por la calculadora además de los proporcionados por la biblioteca estándar. Estos controlan cómo se comporta la calculadora.

### 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 genius-gel-variables sobre evaluar y asignar a variables, y la genius-gel-function-parameters para una lista de configuraciones que se pueden modificar por este método.

Por ejemplo, puede establecer el número máximo de dígitos en un resultado a 12 escribiendo:

    MaxDigits = 12

### Salida

Número máximo de cifras que mostrar

- El número máximo de dígitos en un resultado (`MaxDigits`)

Resultados como números de coma flotante

- Indica si los resultados se imprimirán siempre como números flotantes (`ResultsAsFloats`)

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

- Indica si los números flotantes están en notación científica (`ScientificNotation`)

Imprimir siempre expresiones completas

- Indica si se imprimen expresiones completas para valores de retorno no numéricos (más largos que una línea) (`FullExpressions`))

Usar fracciones mixtas

- Indica si se imprimen las fracciones como fracciones mixtas utilizando la forma «1 1/3» en vez de «4/3». (`MixedFractions`)

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

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

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

- Indica cuándo se corta la salida. Esto lo configura el parámetro `OutputChopWhenExponent`. Consulte la documentación del parámetro `OutputChopExponent`.

Recordar los ajustes de salida entre sesiones

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

Mostrar los errores en una ventana de diálogo

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

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

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

Máximo de errores que mostrar

- 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 genius-gel-function-parameters.

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

Precisión en coma flotante

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

Recordar los ajustes de precisión entre sesiones

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

Líneas de desplazamiento hacia atrás

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

Tipografía

- La tipografía que usar en la terminal.

Negro sobre blanco

- Si usar blanco sobre negro en la terminal.

Cursor parpadeante

- 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

Número máximo de nodos que asignar

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