Referenz der eingebauten Funktionen

Diese Seite listet alle Funktionen auf, die in Varlig Calc eingebaut sind. Du rufst eine Funktion mit ihrem Namen auf und schreibst die Argumente durch Kommas getrennt in Klammern: sqrt(16), round(17.46, 0.05).

Groß- und Kleinschreibung spielt bei Namen keine Rolle, SQRT(16) funktioniert also auch.
Die Anzahl der Argumente wird geprüft. sqrt(4, 9) zeigt einen Fehler an, statt die 9 zu ignorieren.
Zahlen dürfen ihre Tausendertrennzeichen behalten. Ein Komma, auf das drei Ziffern folgen, gruppiert Tausender, und ein Komma mit einem Leerzeichen danach trennt Argumente. max(1,000, 2,000) ergibt also 2.000 und sqrt(1,024) ergibt 32.
Runde oder rechne das Ergebnis einer Funktion in derselben Zeile um, etwa mit sqrt(2) to 4 dp oder abs(-5 km) in m.
Such einen Namen in der Tabelle unten und lies dann im zugehörigen Abschnitt Details und Beispiele nach.

Für viele Funktionen gibt es auch eine englische Formulierung, etwa square root of 16; siehe Mathe in Worten. Wie du eigene Funktionen schreibst, erfährst du unter Eigene Funktionen.

Alle Funktionen

Funktion	Bedeutung
`abs(x)`	Betrag; behält Einheiten; Betrag einer komplexen Zahl
`sign(x)`	−1, 0 oder 1
`int(x)`, `trunc(x)`	Ganzzahliger Anteil, in Richtung null
`round(x)`, `round(x, step)`	Nächste ganze Zahl oder nächstes Vielfaches von `step`
`floor(x)`, `floor(x, step)`	Abrunden, in Richtung minus unendlich
`ceil(x)`, `ceil(x, step)`	Aufrunden, in Richtung plus unendlich
`sqrt(x)`, `cbrt(x)`	Quadrat- und Kubikwurzel; Wurzeln behalten Einheiten, die glatt aufgehen
`exp(x)`, `ln(x)`	Natürliche Exponentialfunktion und natürlicher Logarithmus
`log(x)`, `log10(x)`, `log2(x)`, `logbase(x, b)`	Logarithmen
`sin`, `cos`, `tan`	Trigonometrie im Bogenmaß oder mit einem Winkel wie `30°`
`sind`, `cosd`, `tand`	Trigonometrie in Grad
`asin`, `acos`, `atan`	Umkehrfunktionen der Trigonometrie, Ergebnis im Bogenmaß
`asind`, `acosd`, `atand`	Umkehrfunktionen der Trigonometrie, Ergebnis in Grad
`atan2(y, x)`	Winkel im Bogenmaß unter Berücksichtigung des Quadranten
`sinh`, `cosh`, `tanh`, `asinh`, `acosh`, `atanh`	Hyperbelfunktionen
`factorial(n)`, `fact(n)`	Fakultät; auch als `n!` schreibbar
`gcd(a, b)`, `lcm(a, b)`	Größter gemeinsamer Teiler und kleinstes gemeinsames Vielfaches; exakt, auch für Brüche
`combination(n, k)`, `permutation(n, k)`	Anzahl der Auswahlmöglichkeiten
`clamp(x, low, high)`	Wert innerhalb von Grenzen halten
`hex(n)`, `bin(n)`	Zahl hexadezimal oder binär anzeigen
`random()`, `rand()`, `random(a, b)`, `rand(a, b)`	Zufallszahlen
`complex(re, im)`, `real`, `imag`, `conj`, `arg`	Komplexe Zahlen
`sum`, `total`, `product`, `average`, `mean`, `avg`, `median`, `min`, `max`, `count`, `length`, `variance`, `stddev`, `stdev`	Summen und Statistik einer Liste (einige akzeptieren auch einzelne Argumente)
`sum(expr, var, lo, hi)`, `summation(...)`, `product(expr, var, lo, hi)`	Summen und Produkte über eine Zählvariable
`range(a, b)`, `range(a, b, step)`	Liste von Zahlen, beide Enden eingeschlossen
`sort`, `reverse`, `unique`, `slice(list, start, end)`	Liste umordnen oder Teile daraus auswählen
`map(expr, var, list)`, `filter(cond, var, list)`	Jedes Element einer Liste berechnen oder prüfen
`dot`, `cross`, `identity(n)`, `shape`, `transpose`, `det`, `inverse`, `trace`, `rank`	Vektoren und Matrizen
`solve_system(A, b)`, `eigenvalues`, `qr`, `lu`, `svd`	Lineare Gleichungssysteme und Matrixzerlegungen
`solve(equation, var, lo, hi)`	Gleichung numerisch zwischen zwei Grenzen lösen
`differentiate(expr, var)`, `derivative(expr, var)`	Ableitung als Formel
`differentiate(expr, var, point)`, `derivative(expr, var, point)`	Ableitung an einer Stelle, als Zahl
`integrate(expr, var, lo, hi)`	Bestimmtes Integral, numerisch berechnet
`easter(year)`	Westlicher Ostersonntag
`tyre_speed(width, aspect, rim, rotation)`	Fahrgeschwindigkeit aus Reifengröße und Raddrehzahl

Zahlen und Zählen

Funktion	Argumente und Bedeutung
`abs(x)`	Betrag; behält die Einheit einer Größe; Betrag einer komplexen Zahl
`sign(x)`	Vorzeichen einer einfachen reellen Zahl: -1, 0 oder 1
`int(x)`, `trunc(x)`	Ganzzahliger Anteil, in Richtung null
`sqrt(x)`	Quadratwurzel; für eine negative Zahl fragst du nach einer komplexen Wurzel: `sqrt(-16 + 0i)`
`cbrt(x)`	Kubikwurzel, auch von negativen Zahlen
`factorial(n)`, `fact(n)`	Fakultät einer ganzen Zahl ab 0; auch als `n!` schreibbar
`gcd(a, b)`	Größter gemeinsamer Teiler zweier exakter Zahlen, nie negativ
`lcm(a, b)`	Kleinstes gemeinsames Vielfaches zweier exakter Zahlen, nie negativ
`clamp(x, low, high)`	Wert zwischen `low` und `high` halten, alle von derselben Art; untere Grenze zuerst
`permutation(n, k)`	Geordnete Auswahl von `k` Elementen aus `n`
`combination(n, k)`	Ungeordnete Auswahl von `k` Elementen aus `n`
`hex(x)`, `bin(x)`	Zahl hexadezimal oder binär anzeigen

calc

abs(-£45.20) ergibt £45.20

sign(-5) ergibt -1

int(7.8) ergibt 7

sqrt(144 m^2) ergibt 12 m

cbrt(-27) ergibt -3

factorial(5) ergibt 120

gcd(1920, 1080) ergibt 120

lcm(4, 6) ergibt 12

clamp(115, 0, 100) ergibt 100

clamp(£120, £0, £100) ergibt £100.00

combination(10, 2) ergibt 45

permutation(8, 3) ergibt 336

hex(255) ergibt 0xFF

bin(10) ergibt 0b1010

Ein paar Beispiele aus dem Alltag: gcd(1920, 1080) zeigt, dass ein Bildschirm mit 1920 × 1080 das Format 16:9 hat (1920 ÷ 120 zu 1080 ÷ 120). combination(10, 2) ist die Zahl der verschiedenen Paare in einer Gruppe von zehn, und permutation(8, 3) die Zahl der Möglichkeiten, Gold, Silber und Bronze unter acht Läuferinnen und Läufern zu vergeben.

clamp behält bei Geld, Größen und Dauern die Einheit, wenn der Wert und beide Grenzen dasselbe messen. So deckelt clamp(£120, £0, £100) eine Erstattung bei £100.00. Verwende für Fakultäten und Auswahlen ganze Zahlen, bei denen k nicht größer als n ist. 5! ist eine kürzere Schreibweise für factorial(5). Für andere Wurzeln verwendest du die Formulierung root 3 of 27; eine allgemeine Funktion root(...) gibt es nicht.

Runden

round, floor und ceil akzeptieren optional eine Schrittweite, auf die gerundet wird:

calc

round(17.46, 0.05) ergibt 17.45

ceil(23, 6) ergibt 24

floor(7.8) ergibt 7

ceil(23, 6) rundet 23 Eier auf volle Sechserkartons auf. Die Schrittweite ist keine Anzahl von Nachkommastellen: round(17.456, 2) rundet auf das nächste Vielfache von 2 und ergibt 18, und ein Hinweis an round schlägt stattdessen 17.456 to 2 dp vor. Für signifikante Stellen schreibst du to 3 sf. Unter Runden erfährst du mehr über halbe Werte, negative Zahlen und Geldbeträge.

Trigonometrie und Winkel

Funktionsfamilie	Bedeutung
`sin`, `cos`, `tan`	Trigonometrie; eine einfache Zahl gilt als Bogenmaß
`sind`, `cosd`, `tand`	Trigonometrie einer einfachen Zahl in Grad
`asin`, `acos`, `atan`	Umkehrfunktionen der Trigonometrie; das Ergebnis hat die Einheit rad
`asind`, `acosd`, `atand`	Umkehrfunktionen der Trigonometrie, Ergebnis in Grad
`atan2(y, x)`	Winkel unter Berücksichtigung des Quadranten, als einfache Zahl im Bogenmaß
`sinh`, `cosh`, `tanh`	Hyperbelfunktionen
`asinh`, `acosh`, `atanh`	Umkehrfunktionen der Hyperbelfunktionen

calc

sin(30°) ergibt 0.5

cosd(60) ergibt 0.5

tan(45°) ergibt 1

sin(pi/2) ergibt 1

asind(0.5) ergibt 30°

asin(1) ergibt 1.5707963268 rad

asin(0.5) in degrees ergibt 30°

atan2(-1, -1) * 180 / pi ergibt -135

cosh(0) ergibt 1

sin, cos und tan akzeptieren einen Winkel in jeder Winkeleinheit, etwa 30° oder 30 degrees. Um das Ergebnis von asin, acos oder atan in Grad zu sehen, hängst du wie oben in degrees an oder verwendest die Grad-Varianten.

atan2 erwartet zuerst den y-Wert und ermittelt, in welchem Quadranten der Winkel liegt. So zeigt atan2(-1, -1) nach links unten (−135°), während atan(1) allein das nicht unterscheiden kann.

Hyperbelfunktionen erwarten einfache Zahlen. Umkehrfunktionen akzeptieren nur Werte aus ihrem reellen Definitionsbereich; asin(2) zeigt zum Beispiel Error: imaginary number an. Für komplexe Ergebnisse siehe Komplexe Zahlen.

Logarithmen und Exponentialfunktionen

Funktion	Bedeutung
`ln(x)`	Natürlicher Logarithmus
`log(x)`, `log10(x)`	Logarithmus zur Basis 10
`log2(x)`	Logarithmus zur Basis 2
`logbase(x, b)`	Logarithmus von `x` zur Basis `b`
`exp(x)`	Natürliche Exponentialfunktion

calc

log(1000) ergibt 3

log10(1000000) ergibt 6

log2(1024) ergibt 10

logbase(81, 3) ergibt 4

ln(exp(2)) ergibt 2

exp(0) ergibt 1

Ein Logarithmus braucht eine positive Zahl: log(0) zeigt Error: ∞ an und log(-100) zeigt Error: imaginary number. Für den komplexen Logarithmus schreibst du die Zahl als komplexe Zahl, etwa ln(-1 + 0i). Die Basis muss positiv und ungleich 1 sein. Logarithmen, Exponentialfunktionen und Hyperbelfunktionen akzeptieren keine Einheiten und keine Geldbeträge.

Zufallswerte

calcErgebnisse hängen vom heutigen Datum oder von Live-Daten ab

random number between 1 and 6 ergibt 4

random(1, 6) ergibt 2

rand(1, 100) ergibt 57

random() ergibt 0.4381930527

rand() ergibt 0.9102746385

random(0, 1) ergibt 0.2373052626

random(a, b) und die Formulierung random number between a and b liefern eine ganze Zahl von a bis b, beide Enden eingeschlossen.
random() liefert einen Bruch von 0 bis ausschließlich 1. random(0, 1) ist ein Sonderfall, der dasselbe tut.
rand ist ein anderer Name für random.
Die Grenzen müssen einfache ganze Zahlen im Bereich von 64-Bit-Ganzzahlen sein, die kleinere zuerst. Ein einzelnes Argument, mehr als zwei, Brüche oder vertauschte Grenzen führen zu einem Fehler.
Varlig kann bei jeder Neuberechnung der Notiz eine neue Zahl ziehen. Speichere eine Ziehung in einer Variablen, etwa Wurf = random(1, 6), wenn spätere Zeilen dieselbe Zahl verwenden sollen.

Listen und Statistik

calc

average([12, 18, 9, 21]) ergibt 15

median([3, 9, 4, 7, 5]) ergibt 5

sum([£12.50, £8, £4.25]) ergibt £24.75

max(4, 9, 2) ergibt 9

stddev([2, 4, 6]) ergibt 2

sum(k, k, 1, 100) ergibt 5,050

range(0, 20, 5) ergibt [0, 5, 10, 15, 20]

sort([3, 1, 2]) ergibt [1, 2, 3]

slice([10, 20, 30, 40], 1, 3) ergibt [20, 30]

map(x * 1.2, x, [£10, £25]) ergibt [£12.00, £30.00]

filter(x > 10, x, [4, 12, 18]) ergibt [12, 18]

sum (auch total), product, average (auch mean und avg), median, min, max, count, length, variance und stddev (auch stdev) arbeiten mit einer Liste, einige akzeptieren auch einzelne Argumente. Eine Perzentilfunktion gibt es nicht. sum, summation und product mit vier Argumenten addieren oder multiplizieren einen Ausdruck, während eine Zählvariable von lo bis hi läuft. reverse und unique erwarten ebenfalls eine Liste. Unter Listen und Statistik erfährst du mehr über Positionen in slice, Stichproben- und Grundgesamtheitsstatistik und mehr.

Vektoren, Matrizen und Analysis

calc

dot([1, 2, 3], [4, 5, 6]) ergibt 32

det([[2, 1], [1, 3]]) ergibt 5

solve_system([[1, 1], [1, -1]], [10, 2]) ergibt [6, 4]

solve(x * 1.2 = 60, x, 0, 100) ergibt 50

differentiate(x^2, x, 3) ergibt 6

integrate(x^2, x, 0, 3) ergibt 9

solve_system([[1, 1], [1, -1]], [10, 2]) findet zwei Zahlen, deren Summe 10 und deren Differenz 2 ist. solve(x * 1.2 = 60, x, 0, 100) sucht zwischen 0 und 100 den Preis vor 20 % Mehrwertsteuer, der 60 ergibt. Zu cross, identity, shape, transpose, inverse, trace, rank, eigenvalues, qr, lu und svd siehe Vektoren und Matrizen. Zu Ableitungen als Formeln und den Grenzen des Lösers und des Integrators siehe Summen, Gleichungen lösen und Analysis und Höhere Mathematik: Möglichkeiten und Grenzen.

Komplexe Zahlen

calc

abs(3 + 4i) ergibt 5

complex(3, 4) ergibt 3 + 4i

conj(3 + 4i) ergibt 3 - 4i

real(3 + 4i) ergibt 3

imag(3 + 4i) ergibt 4

arg(z) liefert den Winkel einer komplexen Zahl im Bogenmaß. Siehe Komplexe Zahlen.

Datum und Fahrzeuge

calc

easter(2030) ergibt April 21, 2030

tyre_speed(205, 55, 16, 1000 rpm) in km/h ergibt 119.1103438682 km/h

easter(year) liefert den westlichen Ostersonntag eines Jahres, dasselbe Datum wie die Formulierung Easter 2030. Du kannst direkt von ihm aus Tage zählen, etwa mit easter(2030) + 1 day. Siehe Datum und Kalender. tyre_speed erwartet die Reifenbreite in Millimetern, das Querschnittsverhältnis in Prozent, den Felgendurchmesser in Zoll und die Drehzahl des Rades; siehe Kochen, Klang, Bildschirme und Mechanik.