# Zahlen und Mathematik Zahlen treiben viele Ninox Apps an. Du nutzt sie für Preise, Mengen, Bewertungen, Dauern, Prozentwerte und alle Arten von Berechnungen.
Funktion (A-Z)Aufgabe
abs()Entfernt das Vorzeichen einer Zahl
acos()Berechnet den Arkuskosinus einer Zahl
asin()Berechnet den Arkussinus einer Zahl
atan()Berechnet den Arkustangens einer Zahl
atan2()Gibt den Arkustangens eines Quotienten zurück
avg()Berechnet den Durchschnitt numerischer Werte
ceil()Rundet eine Zahl zur nächsten ganzen Zahl auf
cos()Berechnet den Kosinus eines Winkels
degrees()Konvertiert Radiant in Grad
even()Prüft, ob eine Zahl gerade ist
exp()Berechnet die natürliche Exponentialfunktion
floor()Rundet eine Zahl zur nächsten ganzen Zahl ab
ln()Berechnet den natürlichen Logarithmus
log()Berechnet einen Logarithmus zur Basis 10 oder einer anderen Basis
max()Gibt den größten oder spätesten Wert zurück
min()Gibt den kleinsten oder frühesten Wert zurück
number()Konvertiert einen Wert in eine Zahl oder gibt die ID eines Auswahlwerts zurück
numbers()Gibt IDs aus einem Mehrfachauswahlfeld zurück
odd()Prüft, ob eine Zahl ungerade ist
pow()Hebt eine Zahl auf eine Potenz
random()Erzeugt eine Zufallszahl zwischen 0 und 1
radians()Konvertiert Grad in Radiant
range()Erzeugt ein Array aus aufeinanderfolgenden Zahlen
round()Rundet eine Zahl auf eine ganze Zahl oder Dezimalstelle
sign()Gibt zurück, ob eine Zahl negativ, null oder positiv ist
sin()Berechnet den Sinus eines Winkels
sqr()Quadriert eine Zahl
sqrt()Zieht die Quadratwurzel einer Zahl
sum()Addiert numerische Werte
tan()Berechnet den Tangens eines Winkels
## Durchschnitte, Summen, Minimal- und Maximalwerte berechnen Nutze `avg()`, `sum()`, `min()` und `max()`, um numerische Werte aus Arrays, Datensatzauswahlen oder berechneten Listen zusammenzufassen. Diese Funktionen sind nützlich für Summen, KPIs, Datumsbereiche und schnelle Prüfungen in Logikfeldern. ### Werte mit `avg()` mitteln Nutze `avg()`, um den mathematischen Durchschnitt numerischer Werte aus einem Array oder einer Tabellenauswahl zu berechnen. `avg([number])` * `[number]`: ein Array von Zahlen oder eine Liste numerischer Feldwerte `avg()` gibt ein numerisches Ergebnis für die übergebenen Werte zurück. Du kannst `avg()` verwenden mit: * Zahlenarrays * Spalten in Tabellenansichten, die numerische Werte enthalten #### Schauen wir uns einige Beispiele an: ``` avg([1, 2, 3, 4, 5, 6, 7, 8, 9]) ``` Berechnet den Durchschnitt der Zahlen 1 bis 9.\ Das Skript gibt `5` zurück.
``` avg((select invoices).total) ``` Nimmt alle Datensätze aus der Tabelle "Invoices" und berechnet den Durchschnitt des Felds "Total". ``` avg((select invoices).payment_duration) ``` Berechnet die durchschnittliche Zahlungsdauer über die ausgewählten Rechnungen, wenn `payment_duration` ein numerisches Feld ist. Tipp: * Nutze `avg()` nur mit numerischen Werten. ### Werte mit `sum()` addieren Nutze `sum()`, um numerische Werte aus einem Array oder einer Tabellenauswahl zu addieren. Nutze es, wenn du: * Rechnungsbeträge, Budgets, Zahlungen oder KPI-Felder summieren willst. * Stunden aus verknüpften Datensätzen addieren willst. `sum([number])` * `[number]`: ein Array von Zahlen oder eine Liste numerischer Feldwerte #### Schauen wir uns einige Beispiele an: ``` sum([1, 2, 3, 4, 5, 6, 7, 8, 9]) ``` Addiert die Zahlen 1 bis 9.\ Das Skript gibt `45` zurück.
``` sum((select invoices).total) ``` Summiert das Feld "Total" über alle Datensätze in der Tabelle "Invoices".
``` sum((select invoices where year(date) = 2025).total) ``` Filtert Rechnungen auf 2025 und summiert nur diese Beträge. ### Den kleinsten oder frühesten Wert mit `min()` finden Nutze `min()`, um die kleinste Zahl oder das früheste Datum bzw. den frühesten Zeitstempel in einer Liste zurückzugeben. `min([any])` * `[any]`: ein Array vergleichbarer Werte, meist Zahlen, Datumswerte oder Zeitstempel `min()` gibt einen Wert aus der Liste zurück. Das Ergebnis behält denselben Typ wie die übergebenen Werte: * kleinster Wert bei numerischen Arrays * frühester Wert bei Datums- oder Zeitstempel-Arrays Nutze `min()` nur mit Werten, die sinnvoll verglichen werden können, etwa Zahlen oder zeitbezogene Werte. #### Schauen wir uns einige Beispiele an: ``` min([1, 21, 9, 35]) ``` Gibt die kleinste Zahl in der Liste zurück.\ Das Skript gibt `1` zurück.
``` let currYear := year(now()); let myBirthdays := (select employees).date(currYear, month(birthday), day(birthday)); min(myBirthdays) ``` Die erste Zeile speichert das aktuelle Jahr aus `now()` in einer Variable. Die zweite Zeile erstellt eine Liste von Geburtstagen in diesem Jahr. Die letzte Zeile gibt das früheste Datum in der Liste zurück. ### Den größten oder spätesten Wert mit `max()` finden Nutze `max()`, um die größte Zahl oder das späteste Datum bzw. den spätesten Zeitstempel in einer Liste zurückzugeben. `max([any])` * `[any]`: ein Array vergleichbarer Werte, meist Zahlen, Datumswerte oder Zeitstempel `max()` gibt einen Wert aus der Liste zurück. Das Ergebnis behält denselben Typ wie die übergebenen Werte: * größter Wert bei numerischen Arrays * spätester Wert bei Datums- oder Zeitstempel-Arrays Nutze `max()` nur mit Werten, die sinnvoll verglichen werden können, etwa Zahlen oder zeitbezogenen Werten. #### Schauen wir uns einige Beispiele an: ``` max([1, 21, 9, 35]) ``` Gibt die größte Zahl in der Liste zurück.\ Das Skript gibt `35` zurück.
``` let currYear := year(now()); let birthdays := (select employees).date(currYear, month(birthday), day(birthday)); max(birthdays) ``` Die erste Zeile speichert das aktuelle Jahr aus `now()` in einer Variable. Die zweite Zeile erstellt eine Liste von Geburtstagen in diesem Jahr. Die letzte Zeile gibt das späteste Datum in der Liste zurück. Tipps: * Nutze `avg()` und `sum()` nur für numerische Werte. * Nutze `min()` und `max()` sowohl für Zahlen als auch für zeitbezogene Werte. ## Zahlen aufrunden, abrunden oder auf eine gewünschte Genauigkeit runden Nutze diese Funktionen, wenn du eine sauberere Ausgabe, ganze Zahlen oder feste Dezimalstellen brauchst. ### Mit `ceil()` aufrunden Nutze `ceil()`, um eine Dezimalzahl zur nächsten höheren ganzen Zahl aufzurunden. Nutze es, wenn du: * Mengen, Seiten oder Paketanzahlen aufrunden willst. * Dezimalstellen entfernen und immer zur nächsten ganzen Zahl gehen willst. `ceil(number)` * `number`: der Wert, den du aufrunden willst Wenn die Eingabe bereits eine ganze Zahl ist, bleibt der Wert unverändert. #### Schauen wir uns einige Beispiele an: ``` ceil(2.5) ``` Gibt `3` zurück. ``` ceil(12.00001) ``` Gibt `13` zurück. ``` ceil(27) ``` Gibt `27` zurück. Tipps: * Nutze `ceil()`, wenn Teilwerte als nächste volle Einheit zählen sollen. ### Mit `floor()` abrunden Nutze `floor()`, um eine Dezimalzahl zur nächsten kleineren ganzen Zahl abzurunden. Nutze es, wenn du: * Dezimalstellen entfernen willst, ohne den Wert zu erhöhen. * Dauern, Mengen oder Bewertungen abrunden willst. `floor(number)` * `number`: der Wert, den du abrunden willst Wenn die Eingabe bereits eine ganze Zahl ist, bleibt der Wert unverändert. #### Schauen wir uns einige Beispiele an: ``` floor(2.5) ``` Gibt `2` zurück. ``` floor(12.00001) ``` Gibt `12` zurück. ``` floor(27) ``` Gibt `27` zurück. Tipps: * Nutze `floor()`, wenn du nur vollständig erreichte ganze Einheiten brauchst. ### Mit `round()` auf eine ganze Zahl oder Dezimalstelle runden Nutze `round()`, um eine Zahl auf die nächste ganze Zahl oder auf eine gewünschte Anzahl von Dezimalstellen zu runden. Nutze es, wenn du: * saubere Beträge in Berichten oder Formularen zeigen willst. * Dezimalstellen für Preise, Sätze oder Prozentwerte begrenzen willst. * kaufmännisch runden willst. `round(number)`\ `round(number, digits)` * `number`: der Wert, den du runden willst * `digits`: die Anzahl der Dezimalstellen, die erhalten bleiben sollen `round()` nutzt die normale kaufmännische Rundung: * `5` oder mehr wird aufgerundet * `4` oder weniger wird abgerundet Wenn du `digits` weglässt, rundet Ninox auf die nächste ganze Zahl. #### Schauen wir uns einige Beispiele an: ``` round(2.5) ``` Gibt `3` zurück. ``` round(12.4987) ``` Gibt `12` zurück. ``` round(12.4887, 2) ``` Gibt `12.49` zurück. ``` round(12 / 7, 1) ``` Gibt `1.7` zurück. Tipps: * Nutze `round(number)`, wenn du eine ganze Zahl willst. * Nutze `round(number, digits)`, wenn die Anzeigegenauigkeit wichtig ist. * Nutze `format()` nach dem Runden, wenn das Ergebnis zusätzlich ein festes Anzeigeformat braucht. ## Zufallszahlen und Zahlenbereiche erzeugen Nutze `random()`, um Testwerte oder Prozentwerte zu erzeugen. Nutze `range()`, um Arrays mit aufeinanderfolgenden Zahlen zu erzeugen, die du in Schleifen oder Abbildungen verwenden kannst. ### Zufallszahlen mit `random()` erzeugen Nutze `random()`, um eine Zufallszahl zwischen `0` und `1` zu erzeugen. Nutze es, wenn du: * Werte für Passwörter, Prüfziffern oder ID-ähnliche Hilfswerte erzeugen willst. * Prozentwerte oder Wahrscheinlichkeiten simulieren willst. * nicht lineare Testläufe oder Quizlogik bauen willst. Das Ergebnis ist immer: * größer oder gleich `0` * kleiner als `1` #### Schauen wir uns einige Beispiele an: ``` random() ``` Gibt eine Zufallszahl zwischen 0 und 1 zurück.\ Beispielergebnis: `0.0817465303933449`.
``` floor(random() * 10) ``` Gibt eine ganze Zahl zwischen `0` und `9` zurück.
``` round(random() * 100, 2) ``` Gibt eine Zufallszahl zwischen 0 und 100 mit zwei Dezimalstellen zurück.\ Wenn die zufällig erzeugte Zahl 0.071249890 ist, lautet das Ergebnis `7.12`. ### Zahlenarrays mit `range()` erzeugen Nutze `range()`, um ein Array mit aufeinanderfolgenden Zahlen zu erzeugen. Nutze es, wenn du: * Monate, Tage oder Indexpositionen durchlaufen willst. * Hilfsarrays für wiederholte Berechnungen erzeugen willst. Wenn du nur einen Parameter übergibst, startet Ninox bei `0`.\ Der Startwert ist enthalten. Der Endwert ist ausgeschlossen. Wenn `from` größer als `to` ist, gibt Ninox die Zahlen in umgekehrter Reihenfolge zurück. `range(to)`\ `range(from, to)`\ `range(from, to, step)` * `from`: die erste Zahl in der Liste * `to`: der Punkt, an dem Ninox stoppt * `step`: wie viel bei jedem Schritt addiert oder subtrahiert wird #### Schauen wir uns einige Beispiele an: ``` range(7) ``` Erzeugt das Array `[0, 1, 2, 3, 4, 5, 6]`.
``` range(2, 7) ``` Erzeugt das Array `[2, 3, 4, 5, 6]`.
``` range(7, 2) ``` Erzeugt das Array `[7, 6, 5, 4, 3]`.
``` range(2, 9, 2) ``` Zählt in Zweierschritten nach oben.\ Das Ergebnis ist `[2, 4, 6, 8]`. Tipp: * Der Wert `to` ist nicht enthalten. ## Werte mit `number()` und `numbers()` in Zahlen umwandeln Nutze `number()`, um einen einzelnen Wert in eine Zahl umzuwandeln oder die interne ID eines Werts aus einem Auswahlfeld zurückzugeben. Nutze `numbers()`, um die internen IDs aus Mehrfachauswahlfeldern zurückzugeben. ### Einen Wert mit `number()` in eine Zahl umwandeln Nutze `number()`, wenn ein Feldtyp numerisch werden muss, bevor du damit rechnen kannst. Nutze es, wenn du: * importierten Text wie `"1250"` in einen nutzbaren Betrag umwandeln willst. * Werte aus Auswahlfeldern vergleichen oder berechnen willst, weil die sichtbaren Werte immer Text sind. * Datums- oder Dauerwerte vor erweiterten Berechnungen umwandeln willst. Abhängig von der Eingabe gilt: * `text`, der nur Ziffern enthält, wird zu einer Zahl. * `Dates`, `timestamps`, `time intervals` oder `time` werden zu numerischen Werten in Millisekunden. * `choice fields` geben die numerische ID der ausgewählten Option zurück. `number(any)` * `any`: der Wert, den du in eine Zahl umwandeln willst `number()` gibt ein numerisches Ergebnis zurück. #### Schauen wir uns einige Beispiele an: ``` number(today()) ``` Konvertiert das heutige Datum in einen numerischen Unix-Zeitwert in Millisekunden.
``` number("000075639") ``` Konvertiert Text, der nur aus Ziffern besteht, in eine Zahl.\ Das Skript gibt `75639` zurück.
``` number(priority) ``` Wenn `priority` ein Auswahlfeld ist, gibt dies den numerischen Wert der ausgewählten Option zurück. ``` number(appointment) ``` Konvertiert den Start des Termins in einen numerischen Unix-Zeitwert in Millisekunden. ``` number(endof(appointment)) ``` Konvertiert das Ende des Termins in einen numerischen Unix-Zeitwert in Millisekunden. ``` number(quantity_as_text) * unit_price ``` Konvertiert importierten Text in `quantity_as_text`, bevor er mit `unit_price` multipliziert wird. ### IDs aus Mehrfachauswahlfeldern mit `numbers()` holen Nutze `numbers()`, um die IDs der ausgewählten Werte in einem Mehrfachauswahlfeld zurückzugeben. Nutze es, wenn du: * ausgewählte IDs in Filterlogik wiederverwenden willst. `numbers()` gibt ein Array numerischer IDs zurück. `numbers(multi)` #### Schauen wir uns einige Beispiele an: Angenommen, das Mehrfachauswahlfeld `favorite_sports` hat diese ausgewählten Einträge: * Basketball, ID `1` * Dancing, ID `3` * Sailing, ID `4` * Soccer, ID `5` ``` numbers(favorite_sports) ``` Gibt die internen IDs der ausgewählten Einträge zurück: `[1, 3, 4, 5]`.
``` let selectedSports := numbers(favorite_sports); contains(selectedSports, 3) ``` Prüft, ob die Option mit ID `3` ausgewählt ist. Tipps: * Nutze `number()` vor mathematischen Operationen, wenn der Quellwert noch Text ist. * Nutze `numbers()`, wenn du IDs für Filter oder Vergleiche brauchst. * Verwechsle `number()` und `numbers()` nicht. Das eine konvertiert einen Wert. Das andere gibt eine Liste von IDs zurück. ## Prüfen, ob eine Zahl gerade, ungerade oder positiv bzw. negativ ist Nutze `even()`, `odd()` und `sign()`, um einfache Zahleneigenschaften zu prüfen. Diese Funktionen sind nützlich in Bedingungen, Formatierungsregeln und verzweigter Logik. ### Mit `even()` prüfen, ob eine Zahl gerade ist Nutze `even()`, um zu prüfen, ob eine Zahl ohne Rest durch `2` teilbar ist. Nutze es, wenn du: * Zeilen in einer Tabellenansicht abwechselnd einfärben willst. * Datensätze in wechselnde Gruppen aufteilen willst. * Logik bei jedem zweiten Element in einer Schleife ausführen willst. `even(number)` * `number`: der Wert, den du prüfen willst `even()` gibt einen booleschen Wert zurück: * `true`, wenn die Zahl gerade ist * `false`, wenn die Zahl nicht gerade ist `0` gilt als gerade Zahl. Bei Dezimalwerten gibt `even()` nur dann `true` zurück, wenn der Wert ohne Rest durch `2` teilbar ist. #### Schauen wir uns einige Beispiele an: ``` even(6) ``` Gibt `true` zurück, weil 6 gerade ist. ``` even(7) ``` Gibt `false` zurück, weil 7 nicht gerade ist. ``` even(10 + 12) ``` Gibt `true` zurück, weil das Ergebnis `22` und damit gerade ist. ``` even(0) ``` Gibt `true` zurück, weil `0` gerade ist. ``` even(10.2) ``` Gibt `false` zurück, weil `10.2` nicht ohne Rest durch `2` teilbar ist. ``` if even(rec_id) then "lightgray" else "white" end ``` Verwendet `even()` in einer Bedingung, um Zeilenfarben abzuwechseln. ### Mit `odd()` prüfen, ob eine Zahl ungerade ist Nutze `odd()`, um zu prüfen, ob eine Zahl nicht ohne Rest durch `2` teilbar ist. Nutze es, wenn du dasselbe wie mit `even()` tun willst, aber für ungerade Zahlen. `odd(number)` * `number`: der Wert, den du prüfen willst `odd()` gibt einen booleschen Wert zurück: * `true`, wenn die Zahl ungerade ist * `false`, wenn die Zahl nicht ungerade ist `0` ist gerade. Deshalb gibt `odd(0)` `false` zurück. Bei Dezimalwerten gibt `odd()` `true` zurück, wenn der Wert nicht ohne Rest durch `2` teilbar ist. #### Schauen wir uns einige Beispiele an: ``` odd(5) ``` Gibt `true` zurück, weil 5 ungerade ist. ``` odd(10) ``` Gibt `false` zurück, weil 10 nicht ungerade ist. ``` odd(10 + 12) ``` Gibt `false` zurück, weil das Ergebnis `22` und damit gerade ist. ``` odd(0) ``` Gibt `false` zurück, weil `0` gerade ist. ``` odd(10.2) ``` Gibt `true` zurück, weil `10.2` nicht ohne Rest durch `2` teilbar ist. ``` if odd(rec_id) then "▶" else "" end ``` Zeigt eine Markierung nur für ungerade Zeilen an. ### Mit `sign()` das Vorzeichen einer Zahl bestimmen Nutze `sign()`, um zu prüfen, ob eine Zahl negativ, null oder positiv ist. Nutze es, wenn du: * Salden als Soll, null oder Haben kennzeichnen willst. * Lageränderungen als Eingang oder Ausgang klassifizieren willst. * Logik anhand von Gewinn oder Verlust verzweigen willst. `sign(number)` * `number`: der Wert, den du prüfen willst `sign()` gibt zurück: * `-1` für negative Werte * `1` für null und positive Werte #### Schauen wir uns einige Beispiele an: ``` sign(-5) ``` Gibt `-1` zurück, weil `-5` negativ ist. ``` sign(0) ``` Gibt `1` zurück, weil `0` als positiv behandelt wird. ``` sign(12.7) ``` Gibt `1` zurück, weil `12.7` positiv ist. ``` if sign(balance) = -1 then "Overdrawn" else "In credit" end ``` Verzweigt deine Logik danach, ob der Wert negativ ist oder nicht. Tipps: * Nutze `sign()`, wenn die Richtung eines Werts wichtiger ist als seine Größe. * Denk daran: `0` wird als positiv und gerade behandelt. ## Mit Absolutwerten, Potenzen, Wurzeln und Logarithmen arbeiten Nutze diese Funktionen für fortgeschrittene Berechnungen mit Abständen, Wachstum, Exponenten oder Verhältnissen. * `abs()` entfernt das Vorzeichen einer Zahl. * `sqr()` und `sqrt()` quadrieren eine Zahl oder ziehen ihre Quadratwurzel. * `pow()` hebt eine Zahl auf eine beliebige Potenz. * `exp()` berechnet die natürliche Exponentialfunktion. * `ln()` und `log()` berechnen Logarithmen. ### Mit `abs()` einen positiven Wert erhalten Nutze `abs()`, wenn du die Größe einer Zahl brauchst, aber nicht ihr Vorzeichen. Die Funktion gibt den Absolutwert einer Zahl zurück. Nutze es, wenn du: * den Abstand zwischen zwei Zahlen zeigen willst. * Abweichungen vergleichen willst, ohne die Richtung zu berücksichtigen. `abs(number)` * `number`: der numerische Wert, den du ohne Vorzeichen haben willst `abs()` gibt zurück: * denselben Wert für positive Zahlen * `0` für null * die positive Form einer negativen Zahl #### Schauen wir uns einige Beispiele an: ``` abs(-9.3) ``` Entfernt das Minuszeichen und gibt `9.3` zurück. ``` abs(9.3) ``` Lässt den Wert unverändert und gibt `9.3` zurück. ``` abs(0) ``` Gibt `0` zurück. ``` abs(actual_hours - planned_hours) ``` Gibt die Abweichung zwischen Ist- und Planstunden als positiven Wert zurück. ``` abs(income - cost) ``` Gibt die Differenz als positiven Wert zurück, auch wenn die Kosten höher als die Einnahmen sind. ### Mit `sqr()` eine Zahl quadrieren Nutze `sqr()`, um eine Zahl mit sich selbst zu multiplizieren. Das Ergebnis ist immer positiv. `sqr(number)` * `number`: der Wert, den du quadrieren willst #### Schauen wir uns einige Beispiele an: ``` sqr(3) ``` Berechnet `3 * 3` und gibt `9` zurück. ``` sqr(-3) ``` Berechnet `(-3) * (-3)` und gibt `9` zurück. ``` sqr(6 - 9) ``` Berechnet zuerst `-3`. Danach wird das Ergebnis quadriert und `9` zurückgegeben. ### Mit `sqrt()` die Quadratwurzel ziehen Nutze `sqrt()`, um die Quadratwurzel einer positiven Zahl zu berechnen. Wenn die Eingabe negativ sein kann, konvertiere sie zuerst. Ein gängiges Muster ist `sqrt()` zusammen mit `abs()`. `sqrt(number)` * `number`: der Wert, aus dem du die Quadratwurzel ziehen willst #### Schauen wir uns einige Beispiele an: ``` sqrt(3) ``` Gibt `1.7320508075688772` zurück. ``` sqrt(9) ``` Gibt `3` zurück. ``` sqrt(-9) ``` Gibt ein ungültiges Ergebnis zurück, weil die Eingabe negativ ist. ``` sqrt(abs(9 - 13)) ``` Wandelt zuerst `-4` in `4` um. Danach gibt die Funktion `2` zurück. ### Mit `pow()` eine Zahl auf eine Potenz heben Nutze `pow()`, um eine Basiszahl auf einen beliebigen Exponenten zu heben. Nutze es, wenn du: * Formeln bauen willst, bei denen sich der Exponent ändert. `pow(base, exponent)` * `base`: die Basiszahl * `exponent`: die anzuwendende Potenz Wenn du einen gebrochenen Exponenten verwendest, gibt `pow()` die passende Wurzel zurück: * `0.5` gibt die Quadratwurzel zurück * `1 / 3` gibt die Kubikwurzel zurück Bei gebrochenen Exponenten kann das Ergebnis eine Näherung sein und kein perfekt gerundeter Wert. Das ist bei Fließkomma-Berechnungen normal. #### Schauen wir uns einige Beispiele an: ``` pow(4, 3) ``` Berechnet `4` hoch `3`.\ Das Ergebnis ist `64`. ``` pow(64, 0.5) ``` Verwendet den Exponenten `0.5`, der der Quadratwurzel entspricht.\ Das Ergebnis ist `8`. ``` pow(64, 1 / 3) ``` Berechnet die Kubikwurzel von `64`.\ Das Ergebnis kann `3.9999999999999996` statt genau `4` sein. Das liegt an der Fließkomma-Genauigkeit.\ In solchen Fällen kannst du `pow()` mit `round()` kombinieren. ``` pow(1.05, 12) ``` Berechnet 12 Perioden mit 5 % Zinseszins. ### Mit `exp()` die natürliche Exponentialfunktion nutzen Nutze `exp()`, wenn du die Eulersche Zahl `e` hoch einen Exponenten brauchst. Nutze es, wenn du: * fortgeschrittene Bewertungsformeln anwenden willst. * Berechnungen umkehren willst, die `ln()` verwenden. `exp(number)` * `number`: der Exponent `exp()` berechnet die natürliche Exponentialfunktion mit der Eulerschen Zahl `e` als Basis. #### Schauen wir uns einige Beispiele an: ``` exp(1) ``` Berechnet `e^1`.\ Das Ergebnis ist `2.718281828459045`. ``` exp(0) ``` Gibt `1` zurück. ``` exp(5 - 2) ``` Berechnet zuerst `3`. Danach wird `e^3` zurückgegeben, also `20.085536923187668`. ### Mit `ln()` den natürlichen Logarithmus berechnen Nutze `ln()`, um den natürlichen Logarithmus einer Zahl zu berechnen. Das ist der Logarithmus zur Basis `e`. Nutze es, wenn du: * eine Berechnung umkehren willst, die `exp()` verwendet. * sehr große Wertebereiche komprimieren willst. * fortgeschrittene Formeln für Wachstum oder Normalisierung nutzen willst. `ln(number)` * `number`: der Wert, von dem du den Logarithmus haben willst `ln()` gibt ein numerisches Ergebnis zurück. Für `ln()` gilt: * Positive Werte geben eine reelle Zahl zurück. * `0` gibt `-∞` zurück. * Negative Werte sind ungültig. #### Schauen wir uns einige Beispiele an: ``` ln(1) ``` Gibt `0` zurück, weil `e^0 = 1`. ``` ln(0) ``` Gibt `-∞` zurück. ``` ln(100) ``` Gibt `4.605170185988092` zurück. ``` ln(exp(3)) ``` Gibt einen Wert nahe `3` zurück. ### Mit `log()` Logarithmen mit anderen Basen berechnen Nutze `log()`, wenn du einen Logarithmus zur Basis `10` oder einer anderen Basis brauchst. Nutze es, wenn du: * große Werte auf eine kleinere Skala bringen willst. * mit Formeln arbeiten willst, die Basis 10 oder eigene Basen verwenden. `log(number)`\ `log(number, number)` * erste `number`: der Wert, von dem du den Logarithmus haben willst * zweite `number`: die Basis. Wenn du sie weglässt, nutzt Ninox die Basis `10` Für `log()` gilt: * Positive Werte geben eine reelle Zahl zurück. * `0` gibt `-∞` zurück. * Negative Werte sind ungültig. #### Schauen wir uns einige Beispiele an: ``` log(1) ``` Gibt `0` mit der Standardbasis `10` zurück. ``` log(0) ``` Gibt `-∞` zurück. ``` log(3, 5) ``` Berechnet den Logarithmus von `3` zur Basis `5`.\ Das Ergebnis ist `0.6826061944859853`. ``` log(followers, 10) ``` Komprimiert große Follower-Zahlen, damit sie sich in einer Bewertung leichter vergleichen lassen. Tipps: * Nutze `pow()`, wenn der Exponent variabel ist. * Nutze `exp()`, `ln()` und `log()` nur, wenn deine Formel sie wirklich braucht. In der alltäglichen App-Logik sind sie seltener. ## Sinus, Kosinus und Tangens berechnen Nutze diese Funktionen, wenn du direkt mit Winkeln in trigonometrischen Formeln arbeiten willst. ### Den Kosinus mit `cos()` berechnen Nutze `cos()`, um den Kosinus eines Winkels im Bogenmaß zurückzugeben. Nutze es, wenn du: * einen Winkel in einen Kosinuswert umwandeln willst. * trigonometrische Werte in Berechnungen wiederverwenden willst. `cos(number)` * `number`: der Winkel im Bogenmaß `cos()` gibt eine Zahl zwischen `-1` und `1` zurück. #### Schauen wir uns einige Beispiele an: ``` cos(-0.25) ``` Gibt `0.9689124217106447` zurück. Tipps: * `cos()` erwartet Radiant, keine Grad. * Nutze `degrees()` oder `radians()`, wenn du Winkeleinheiten vorher umrechnen musst. ### Den Sinus mit `sin()` berechnen Nutze `sin()`, um den Sinus eines Winkels zurückzugeben. Nutze es, wenn du: * einen Winkel in einen Sinuswert umwandeln willst. `sin(number)` * `number`: der Winkelwert `sin()` gibt eine Zahl zwischen `-1` und `1` zurück. #### Schauen wir uns einige Beispiele an: ``` sin(-0.25) ``` Gibt `-0.24740395925452294` zurück. ``` sin(1) ``` Gibt `0.8414709848078965` zurück. Tipp: * Konvertiere die Eingabe zuerst, wenn der Quellwinkel in Grad gespeichert ist. ### Den Tangens mit `tan()` berechnen Nutze `tan()`, um den Tangens eines Winkels zurückzugeben. Nutze es, wenn du: * mit winkelbasierten Berechnungen aus einem einzelnen Wert arbeiten willst. `tan(number)` * `number`: der Winkelwert #### Schauen wir uns einige Beispiele an: ``` tan(1) ``` Gibt `1.5574077246549023` zurück. ``` tan(1.5) ``` Gibt `14.101419947171719` zurück. ``` tan(5) ``` Gibt `-3.380515006246586` zurück. Tipp: * Konvertiere die Eingabe zuerst, wenn der Quellwinkel in Grad gespeichert ist. ## Winkel zwischen Radiant und Grad umrechnen Nutze diese Funktionen, wenn deine Formel eine andere Winkeleinheit braucht als der Ausgangswert. ### Mit `degrees()` Radiant in Grad umrechnen Nutze `degrees()`, um einen Winkel von Radiant in Grad umzuwandeln. Nutze es, wenn du: * trigonometrische Ergebnisse für Menschen in Grad darstellen willst. * Ergebnisse vor weiterer winkelbasierter Logik umrechnen willst. `degrees(number)` * `number`: der Winkel in Radiant #### Schauen wir uns einige Beispiele an: ``` degrees(3.141592653589793) ``` Gibt `180` zurück. Tipps: * Nutze `degrees()`, wenn der Quellwert bereits in Radiant vorliegt. * Das ist besonders nützlich nach trigonometrischen Berechnungen, die Radiant zurückgeben. ### Mit `radians()` Grad in Radiant umrechnen Nutze `radians()`, um einen Winkel von Grad in Radiant umzuwandeln. Nutze es, wenn du: * Gradwerte für trigonometrische Funktionen vorbereiten willst. * Winkeleingaben vor `sin()`, `cos()` oder `tan()` vereinheitlichen willst. `radians(number)` * `number`: der Winkel in Grad #### Schauen wir uns einige Beispiele an: ``` radians(180) ``` Gibt `3.141592653589793` zurück. Tipps: * Nutze `radians()` vor `sin()`, `cos()` und `tan()`, wenn die Eingabe in Grad gespeichert ist. * Halte die Winkeleinheiten in der gesamten Formel konsistent. ## Inverse trigonometrische Funktionen nutzen Nutze diese Funktionen, wenn du einen Winkel aus einem numerischen Wert oder Quotienten ableiten musst. ### Den Arkuskosinus mit `acos()` berechnen Nutze `acos()`, um den Arkuskosinus einer Zahl zurückzugeben. Nutze es, wenn du: * einen Kosinuswert in einen Winkel umwandeln willst. * mit geometrischen oder winkelbasierten Formeln arbeiten willst. `acos(number)` * `number`: der Wert, für den du den Arkuskosinus berechnen willst #### Schauen wir uns einige Beispiele an: ``` acos(-0.25) ``` Gibt `1.8234765819369754` zurück. Tipp: * Nutze `acos()` nur mit Werten von `-1` bis `1`. Werte außerhalb dieses Bereichs liefern kein gültiges Ergebnis. ### Den Arkussinus mit `asin()` berechnen Nutze `asin()`, um den Arkussinus einer Zahl zurückzugeben. Nutze es, wenn du: * einen Sinuswert in einen Winkel umwandeln willst. * winkelbasierte Formeln aus normalisierten Werten bauen willst. `asin(number)` * `number`: der Wert, für den du den Arkussinus berechnen willst #### Schauen wir uns einige Beispiele an: ``` asin(-0.25) ``` Gibt `-0.25268025514207865` zurück. ``` asin(1) ``` Gibt `1.5707963267948966` zurück. ``` asin(2) ``` Gibt ein ungültiges Ergebnis zurück, weil die Eingabe außerhalb des gültigen Bereichs liegt. Tipp: * Nutze `asin()` nur mit Werten von `-1` bis `1`. Wenn du dir beim Bereich nicht sicher bist, prüfe importierte oder berechnete Werte zuerst. ### Den Arkustangens mit `atan()` berechnen Nutze `atan()`, um den Arkustangens einer Zahl zurückzugeben. Nutze es, wenn du: * einen Tangenswert in einen Winkel umwandeln willst. * Geometrie- oder Richtungsformeln aus einem Verhältnis bauen willst. `atan(number)` * `number`: der Wert, für den du den Arkustangens berechnen willst #### Schauen wir uns einige Beispiele an: ``` atan(15) ``` Gibt `1.5042281630190728` zurück. Tipps: * Nutze `atan()` wenn du bereits einen einzelnen numerischen Wert oder Quotienten hast. * Nutze `atan2()`, wenn der Quotient aus zwei getrennten Werten stammt. ### Den Arkustangens eines Quotienten mit `atan2()` zurückgeben Nutze `atan2()`, um den Arkustangens des Quotienten aus zwei Zahlen zurückzugeben. Nutze es, wenn du: * einen Winkel aus zwei Werten berechnen willst. * den Quotienten nicht erst in einem separaten Schritt berechnen willst. `atan2(number, number)` * erste `number`: der Zählerwert * zweite `number`: der Nennerwert `atan2()` gibt eine Zahl zurück. #### Schauen wir uns einige Beispiele an: ``` atan2(7, 4) ``` Gibt `1.0516502125483738` zurück. Tipps: * Nutze `atan2()`, wenn deine Formel mit zwei getrennten Werten startet. * Nutze `atan()`, wenn du den endgültigen Quotienten bereits als einzelne Zahl hast. --- # Agent Instructions: Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter: ``` GET https://docs.ninox.com/ninox-scripting/de/automate-your-workflows/work-with-functions/numbers-and-math.md?ask= ``` The question should be specific, self-contained, and written in natural language. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.