Lista de operadores GEL
Anterior | Capítulo 5. Conceptos de GEL | Siguiente

## Lista de operadores GEL

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

`a;b`

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

`a=b`

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

`a:=b`

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

`|a|`

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

  Consulte Mathworld para obtener más información.

`a^b`

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

`a.^b`

  Potencia elemento a elemento. Eleva cada elemento de una matriz `a` a la `b`-ésima potencia. O si `b` es una matriz del mismo tamaño que `a`, entonces realiza la operación elemento a elemento. Si `a` es un número y `b` es una matriz entonces crea una matriz del mismo tamaño que `b` formada por `a` elevado a todas las diferentes potencias de `b`.

`a+b`

  Adición. Suma dos números, matrices, funciones o cadenas. Si suma una cadena a cualquier valor el resultado es una cadena. Si uno de ellos es una matriz cuadrada y el otro un número, el número se multiplica por la identidad de la matriz.

`a-b`

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

`a*b`

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

`a.*b`

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

`a/b`

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

`a./b`

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

`a\b`

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

`a.\b`

  División hacia atrás elemento por elemento.

`a%b`

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

`a.%b`

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

`a mod b`

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

`a!`

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

`a!!`

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

`a==b`

  Operador de igualdad, devuelve `true` o `false` dependiendo de si `a` y `b` son iguales o no.

`a!=b`

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

`a<>b`

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

`a<=b`

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

`a>=b`

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

`a<b`

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

`a>b`

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

`a<=>b`

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

`a and b`

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

`a or b`

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

`a xor b`

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

`not a`

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

`-a`

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

`&a`

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

`*a`

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

`a'`

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

`a.'`

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

`a@(b,c)`

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

`a@(b,)`

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

`a@(b,:)`

  Igual que el anterior

`a@(,c)`

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

`a@(:,c)`

  Igual que el anterior

`a@(b)`

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

`a:b`

  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`

  Convierte `a` en 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.

### Nota

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.

### Nota

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)

### Nota

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.

Anterior | Subir | Siguiente
Evaluación modular | Inicio | Capítulo 6. Programar con GEL