Numerische Funktionen

Numerische Operatoren

Die folgende Tabelle zeigt die verfügbaren mathematischen Operatoren für numerische Typen.

Operator	Beschreibung	Beispiel	Ergebnis
`+`	Addition	`2 + 3`	`5`
`-`	Subtraktion	`2 - 3`	`-1`
`*`	Multiplikation	`2 * 3`	`6`
`/`	Gleitkommadivision	`5 / 2`	`2.5`
`//`	Division	`5 // 2`	`2`
`%`	Modulo (Rest)	`5 % 4`	`1`
`**`	Exponent	`3 ** 4`	`81`
`^`	Exponent (Alias für `**`)	`3 ^ 4`	`81`
`&`	Bitweises UND	`91 & 15`	`11`
`	`	Bitweises ODER	`32
`<<`	Bitweise Verschiebung nach links	`1 << 4`	`16`
`>>`	Bitweise Verschiebung nach rechts	`8 >> 2`	`2`
`~`	Bitweise Negation	`~15`	`-16`
`!`	Fakultät von `x`	`4!`	`24`

Divisions- und Modulooperatoren

Es gibt zwei Divisionsoperatoren: / und //. Sie sind gleichwertig, wenn mindestens einer der Operanden ein FLOAT oder ein DOUBLE ist. Sind beide Operanden Ganzzahlen, führt / eine Gleitkommadivision durch (5 / 2 = 2.5), während // eine Ganzzahldivision durchführt (5 // 2 = 2).

Unterstützte Typen

Die Operatoren Modulo, bitweise, Negation und Fakultät wirken nur auf ganzzahlige Datentypen, die übrigen sind für alle numerischen Datentypen verfügbar.

Numerische Funktionen

Die folgende Tabelle zeigt die verfügbaren mathematischen Funktionen.

Name	Beschreibung
`@(x)`	Absolutwert. Klammern sind optional, wenn `x` ein Spaltenname ist.
`abs(x)`	Absolutwert.
`acos(x)`	Berechnet den Arkuskosinus von `x`.
`acosh(x)`	Berechnet den Areakosinus hyperbolicus von `x`.
`add(x, y)`	Alias für `x + y`.
`asin(x)`	Berechnet den Arkussinus von `x`.
`asinh(x)`	Berechnet den Areasinus hyperbolicus von `x`.
`atan(x)`	Berechnet den Arkustangens von `x`.
`atanh(x)`	Berechnet den Areatangens hyperbolicus von `x`.
`atan2(y, x)`	Berechnet den Arkustangens von `(y, x)`.
`bit_count(x)`	Gibt die Anzahl gesetzter Bits zurück.
`cbrt(x)`	Gibt die Kubikwurzel der Zahl zurück.
`ceil(x)`	Rundet die Zahl auf.
`ceiling(x)`	Rundet die Zahl auf. Alias von `ceil`.
`cos(x)`	Berechnet den Kosinus von `x`.
`cot(x)`	Berechnet den Kotangens von `x`.
`degrees(x)`	Wandelt Radiant in Grad um.
`divide(x, y)`	Alias für `x // y`.
`even(x)`	Rundet zur nächsten geraden Zahl, weg von null.
`exp(x)`	Berechnet `e ** x`.
`factorial(x)`	Siehe den Operator `!`. Berechnet das Produkt der aktuellen Ganzzahl und aller kleineren Ganzzahlen.
`fdiv(x, y)`	Führt eine Ganzzahldivision (`x // y`) nach der Floor-Definition durch und gibt einen `DOUBLE`-Wert zurück.
`floor(x)`	Rundet die Zahl ab.
`fmod(x, y)`	Berechnet den Modulo-Wert nach der Floor-Definition. Gibt immer einen `DOUBLE`-Wert zurück.
`gamma(x)`	Interpolation der Fakultät von `x - 1`. Gebrochene Eingaben sind erlaubt.
`gcd(x, y)`	Berechnet den größten gemeinsamen Teiler von `x` und `y`.
`greatest_common_divisor(x, y)`	Berechnet den größten gemeinsamen Teiler von `x` und `y`.
`greatest(x1, x2, ...)`	Wählt den größten Wert.
`isfinite(x)`	Gibt wahr zurück, wenn der Gleitkommawert endlich ist, andernfalls falsch.
`isinf(x)`	Gibt wahr zurück, wenn der Gleitkommawert unendlich ist, andernfalls falsch.
`isnan(x)`	Gibt wahr zurück, wenn der Gleitkommawert keine Zahl ist, andernfalls falsch.
`lcm(x, y)`	Berechnet das kleinste gemeinsame Vielfache von `x` und `y`.
`least_common_multiple(x, y)`	Berechnet das kleinste gemeinsame Vielfache von `x` und `y`.
`least(x1, x2, ...)`	Wählt den kleinsten Wert.
`lgamma(x)`	Berechnet den Logarithmus der `gamma`-Funktion.
`ln(x)`	Berechnet den natürlichen Logarithmus von `x`.
`log(x)`	Berechnet den Zehnerlogarithmus von `x`.
`log10(x)`	Alias von `log`. Berechnet den Zehnerlogarithmus von `x`.
`log2(x)`	Berechnet den Zweierlogarithmus von `x`.
`multiply(x, y)`	Alias für `x * y`.
`nextafter(x, y)`	Gibt den nächsten Gleitkommawert nach `x` in Richtung `y` zurück.
`pi()`	Gibt den Wert von Pi zurück.
`pow(x, y)`	Berechnet `x` hoch `y`.
`power(x, y)`	Alias von `pow`. Berechnet `x` hoch `y`.
`radians(x)`	Wandelt Grad in Radiant um.
`random()`	Gibt eine Zufallszahl `x` im Bereich `0.0 <= x < 1.0` zurück.
`round_even(v NUMERIC, s INTEGER)`	Alias von `roundbankers(v, s)`. Rundet auf `s` Dezimalstellen nach der Regel rounding half to even. Werte `s < 0` sind erlaubt.
`roundbankers(v NUMERIC, s INTEGER)`	Alias von `round_even(v, s)`. Rundet auf `s` Dezimalstellen nach der Regel rounding half to even. Werte `s < 0` sind erlaubt.
`round(v NUMERIC, s INTEGER)`	Rundet auf `s` Dezimalstellen. Werte `s < 0` sind erlaubt.
`setseed(x)`	Setzt den Seed für die Zufallsfunktion.
`sign(x)`	Gibt das Vorzeichen von `x` als -1, 0 oder 1 zurück.
`signbit(x)`	Gibt zurück, ob das Vorzeichenbit gesetzt ist oder nicht.
`sin(x)`	Berechnet den Sinus von `x`.
`sqrt(x)`	Gibt die Quadratwurzel der Zahl zurück.
`subtract(x, y)`	Alias für `x - y`.
`tan(x)`	Berechnet den Tangens von `x`.
`trunc(x)`	Kürzt die Zahl.
`xor(x, y)`	Bitweises XOR.

`@(x)`

`abs(x)`

`acos(x)`

`acosh(x)`

`add(x, y)`

`asin(x)`

`asinh(x)`

`atan(x)`

`atanh(x)`

`atan2(y, x)`

`bit_count(x)`

`cbrt(x)`

`ceil(x)`

`ceiling(x)`

`cos(x)`

`cot(x)`

`degrees(x)`

`divide(x, y)`

`even(x)`

`exp(x)`

`factorial(x)`

`fdiv(x, y)`

`floor(x)`

`fmod(x, y)`

`gamma(x)`

`gcd(x, y)`

`greatest_common_divisor(x, y)`

`greatest(x1, x2, ...)`

`isfinite(x)`

`isinf(x)`

`isnan(x)`

`lcm(x, y)`

`least_common_multiple(x, y)`

`least(x1, x2, ...)`

`lgamma(x)`

`ln(x)`

`log(x)`

`log10(x)`

`log2(x)`

`multiply(x, y)`

`nextafter(x, y)`

`pi()`

`pow(x, y)`

`power(x, y)`

`radians(x)`

`random()`

`round_even(v NUMERIC, s INTEGER)`

`roundbankers(v NUMERIC, s INTEGER)`

`round(v NUMERIC, s INTEGER)`

`setseed(x)`

`sign(x)`

`signbit(x)`

`sin(x)`

`sqrt(x)`

`subtract(x, y)`

`tan(x)`

`trunc(x)`

`xor(x, y)`