Lista över GEL-operatorer
Föregående | Kapitel 5. Grunderna i GEL | Nästa

## Lista över GEL-operatorer

Allt i GEL är bara ett uttryck. Uttryck slås samman med olika operatorer. Som vi har sett är till och med avskiljaren helt enkelt en binär operator i GEL. Här är en lista över operatorerna i GEL.

`a;b`

  Avskiljaren, evaluerar helt enkelt både `a` och `b`, men returnerar bara resultatet av `b`.

`a=b`

  Tilldelningsoperatorn. Denna tilldelar `b` till `a` (`a` måste vara ett giltigt vvärde) (observera dock att denna operator kan översättas till `==` om den används där ett booleskt uttryck förväntas)

`a:=b`

  Tilldelningsoperatorn. Tilldelar `b` till `a` (`a` måste vara ett giltigt vvärde) Detta skiljer sig från `=` eftersom det aldrig översätts till `==`.

`|a|`

  Absolutbelopp. Om uttrycket är ett komplext tak kommer resultatet vara avståndet från origo. Till exempel: `|3 * e^(1i*pi)|` returnerar 3.

  Se Mathworld för mer information.

`a^b`

  Exponentiering, upphöjer `a` till exponenten `b`.

`a.^b`

  Elementvis exponentiering. Upphöj varje element i en matris `a` till exponenten `b`. Eller om `b` är en matris med samma storlek som `a`, gör i så fall operationen elementvis. Om `a` är ett tal och `b` är en matris så skapar det en matris av samma storlek som `b` med `a` upphöjt till alla de olika exponenterna i `b`.

`a+b`

  Addition. Adderar två tal, matriser, funktioner eller strängar. Om du lägger till en sträng kommer resultatet att vara en sträng. Om en är en kvadratisk matris och den andra ett tal kommer talet att multipliceras med identitetsmatrisen.

`a-b`

  Subtraktion. Subtrahera två tal, matriser eller funktioner.

`a*b`

  Multiplikation. Detta är vanlig matrismultiplikation.

`a.*b`

  Elementvis multiplikation om `a` och `b` är matriser.

`a/b`

  Division. Då `a` och `b` bara är tal är detta vanlig division. Då de är matriser är detta ekvivalent med `a*b^-1`.

`a./b`

  Elementvis division. Samma som `a/b` för tal, men opererar elementvis på matriser.

`a\b`

  Baklängesdivision. Det vill säga detta är samma sak som `b/a`.

`a.\b`

  Elementvis baklängesdivision.

`a%b`

  Modulooperatorn. Detta slår inte på moduloläget, utan returnerar bara resten av heltalsdivisionen `a/b`.

`a.%b`

  Elementvis modulooperator. Returnerar resten efter elementvis division `a./b` av heltal.

`a mod b`

  Modulär evalueringsoperator. Uttrycket `a` evalueras modulo `b`. Se ”Moduloberäkning”. Vissa funktioner och operatorer beter sig annorlunda modulo ett heltal.

`a!`

  Fakultetsoperator. Detta är som `1*...*(n-2)*(n-1)*n`.

`a!!`

  Semifakultetsoperator. Detta är som `1*...*(n-4)*(n-2)*n`.

`a==b`

  Likhetsoperator. Returnerar `true` eller `false` beroende på om `a` och `b` är lika eller inte.

`a!=b`

  Olikhetsoperator, returnerar `true` om `a` inte är lika med `b`, returnerar annars `false`.

`a<>b`

  Alternativ olikhetsoperator, returnerar `true` om `a` inte är lika med `b`, returnerar annars `false`.

`a<=b`

  Mindre än eller lika med-operator, returnerar `true` om `a` är mindre eller lika med `b`, returnerar annars `false`. Dessa kan kombineras som i `a <= b <= c` (kan också kombineras med mindre än-operatorn).

`a>=b`

  Större än eller lika med-operator, returnerar `true` om `a` är större eller lika med `b`, returnerar annars `false`. Dessa kan kombineras som i `a >= b >= c` (kan också kombineras med större än-operatorn).

`a<b`

  Mindre än-operator, returnerar `true` om `a` är mindre än `b`, returnerar annars `false`. Dessa kan kombineras som i `a < b < c` (kan också kombineras med mindre än eller lika med-operatorn).

`a>b`

  Större än-operator, returnerar `true` om `a` är större än `b`, returnerar annars `false`. Dessa kan kombineras som i `a > b > c` (kan också kombineras med större än eller lika med-operatorn).

`a<=>b`

  Jämförelseoperator. Om `a` är lika med `b` returnerar den 0, om `a` är mindre än `b` returnerar den -1 och om `a` är större än `b` returnerar den 1.

`a and b`

  Logiskt och. Returnerar true om både `a` och `b` är true, returnerar annars false. Om tal gives behandlas nollskilda tal som true.

`a or b`

  Logiskt eller. Returnerar true om antingen `a` eller `b` är true, returnerar annars false. Om tal gives behandlas nollskilda tal som true.

`a xor b`

  Logiskt uteslutande eller. Returnerar true om exakt en av `a` eller `b` är true, returnerar annars false. Om tal gives behandlas nollskilda tal som true.

`not a`

  Logiskt inte. Returnerar den logiska negationen till `a`

`-a`

  Negationsoperator. Returnerar negativet av ett tal eller en matris (arbetar elementvis på en matris).

`&a`

  Variabelreferens (för att skicka en referens till en variabel). Se ”Referenser”.

`*a`

  Variabeldereferering (för att komma åt en refererad variabel). Se ”Referenser”.

`a'`

  Konjugattransponatet för matris. Det vill säga rader och kolumner byter plats och vi tar komplexkonjugatet av alla poster. Det vill säga om i,j-elementet av `a` är x+iy så är j,i-elementet av `a'` då x-iy.

`a.'`

  Matristransponat, konjugerar inte posterna. Det vill säga i,j-elementet av `a` blir j,i-elementet av `a.'`.

`a@(b,c)`

  Hämta element för en matris i rad `b` och kolumn `c`. Om `b`, `c` är vektorer så ger detta de motsvarande raderna, kolumnerna eller delmatriserna.

`a@(b,)`

  Hämta rad av en matris (eller flera rader om `b` är en vektor).

`a@(b,:)`

  Samma som ovan.

`a@(,c)`

  Hämta kolumn av en matris (eller flera kolumner om `b` är en vektor).

`a@(:,c)`

  Samma som ovan.

`a@(b)`

  Hämta ett element från en matris behandlad som en vektor. Detta kommer traversera matrisen radvis.

`a:b`

  Bygg en vektor från `a` till `b` (eller ange en rad- och kolumnregion för `@`-operatorn). Till exempel kan vi för att få raderna 2 till 4 av matrisen `A` göra

      A@(2:4,)

  eftersom `2:4` kommer returnera en vektor `[2,3,4]`.

`a:b:c`

  Bygg en vektor från `a` till `c` med `b` som steglängd. Det vill säga exempelvis

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

  Då de inblandade talen är flyttal, till exempel `1.0:0.4:3.0`, är utmatningen vad som förväntas även om att lägga till 0.4 till 1.0 fem gånger faktiskt är något mindre än 3.0 på grund av sättet som flyttal lagras i bas 2 (det finns inget 0.4, det faktiska lagrade talet är bara något större). Sättet detta hanteras är detsamma som i for-, sum-, och prod-slingorna. Om slutet är inom `2^-20` gånger stegstorleken till ändpunkten, används ändpunkten och vi antar att det fanns avrundningsfel. Detta är inte perfekt, men hanterar de flesta fallen. Denna kontroll görs bara från version 1.0.18 och framåt, så exekvering av din kod kan skilja sig åt i äldre versioner. Använd faktiska rationella tal om du vill undvika att hantera detta problem, möjligen tillsammans med `float` om du vill få flyttal i slutet. Till exempel gör `1:2/5:3` rätt sak och `float(1:2/5:3)` ger dig till och med flyttal och är även något mer exakt än `1.0:0.4:3.0`.

`(a)i`

  Gör `a` till ett imaginärt tal (multiplicera `a` med det imaginära). Observera att `i` vanligen skrivs `1i`, så det ovanstående är detsamma som

      (a)*1i

``a`

  Citera en identifierare så att den inte evalueras. Eller citera en matris så att den inte expanderas.

`a swapwith b`

  Byt värde på `a` med värdet av `b`. Opererar för närvarande inte på intervall av matriselement. Det returnerar `null`. Tillgängligt från version 1.0.13.

`increment a`

  Inkrementera variabeln `a` med 1. Om `a` är en matris inkrementeras varje element. Detta är ekvivalent med `a=a+1`, men är något snabbare. Det returnerar `null`. Tillgängligt från version 1.0.13.

`increment a by b`

  Inkrementera variabeln `a` med `b`. Om `a` är en matris inkrementeras varje element. Detta är ekvivalent med `a=a+b`, men är något snabbare. Det returnerar `null`. Tillgängligt från version 1.0.13.

### Notera

@()-operatorn gör :-operatorn mest användbar. Med denna kan du ange regioner i en matris. Därmed är a@(2:4,6) raderna 2,3,4 för kolumn 6. Eller så ger a@(,1:2) dig de två första kolumnerna i en matris. Du kan också tilldela till @()-operatorn, så länge som högervärdet är en matris som matchar regionens storlek, eller om det är någon annan sorts värde.

### Notera

Jämförelseoperatorerna (förutom <=>-operatorn, vilken beter sig normalt) är inte strikt binära operatorer, de kan i själva verket grupperas på det vanliga matematiska sättet, t.ex. så är (1<x<=y<5) ett giltigt booleskt uttryck och betyder precis vad det borde, det vill säga (1<x och x≤y och y<5)

### Notera

Unärt minus opererar annorlunda beroende på var det förekommer. Om det förekommer före ett tal binder det väldigt hårt, om det förekommer före ett uttryck binder det mindre hårt än potens- och fakultet-operatorerna. Så till exempel är `-1^k` faktiskt `(-1)^k`, men `-foo(1)^k` är verkligen `-(foo(1)^k)`. Så var aktsam över hur du använder det, och om du är osäker, lägg till parenteser.

Föregående | Upp | Nästa
Moduloberäkning | Hem | Kapitel 6. Programmering med GEL