> For the complete documentation index, see [llms.txt](https://docs.qvantum-plan.de/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.qvantum-plan.de/user/owner/planung/modell/rechenoperationen_und_formelsyntax.md). # Formeln QVANTUM unterstützt die auf dieser Seite definierten Rechenoperationen und Formeln. Die hier aufgeführten Rechenoperationen und Formeln lassen sich sowohl im Formelwerk auf dem Unter-Tab "Formeln" des Tabs "Modell" (siehe [Bearbeitung des Formelwerks](/user/owner/planung/modell/segmente_und_kennzahlenformeln.md)) als auch in [Berechnungsspalten von Formularen](/user/owner/planung/formulare/konfiguration-der-formulare/die_drei_modi_der_achsenkonfiguration.md#berechnungszeile-oder-spalte) und über die QVANTUM Public API verwenden. ### Inhalt dieser Seite * [Allgemeine Formelsyntax](#allgemeine-formelsyntax) * [Funktionsreferenz](#funktionsreferenz) ## Allgemeine Formelsyntax #### Grundkonstrukte * Ganzzahlen (z. B. `1`) oder Dezimalzahlen mit Komma (z. B. `29,99`) * Kennzahlenreferenzen in eckigen Klammern (z. B. `[DELTA]`); in Berechnungsspalten von Formularen werden stattdessen Zeilen- oder Spaltenbezeichner referenziert (z. B. `[3]` oder `[B]`) * die Konstante für leere Zellen, `BLANK` (auch: `LEER`) * Vorzeichen (z. B. `-[CST000]` oder `-1,1`) * Operatoren zwischen zwei Werten (z. B. `[A] + 1`, `[A] < [B]`) * runde Klammern zur Gruppierung (z. B. `([A]-[B])/[C]`) * Funktionsaufrufe, auch verschachtelt (z. B. `ABS(DIVIDIEREN([1];[2];BLANK))`) * Boolesche Ausdrücke, die zu `TRUE` oder `FALSE` ausgewertet werden und selbst wieder kombiniert werden können (z. B. `([A] > [B]) && ([C] < [D])`) * Leerzeichen (werden beim Auswerten ignoriert; `1 + 2` ist gleichbedeutend mit `1+2`) #### Rechenoperatoren * Addition (`+`) * Subtraktion (`-`) * Multiplikation (`*`) * Division (`/`) #### Vergleichsoperatoren Ein Vergleichsoperator verknüpft zwei Werte zu einem Ausdruck, der zu `TRUE` oder `FALSE` ausgewertet wird — etwa als Bedingung in einer `WENN`-Formel. | Operator | Bedeutung | | -------------- | ------------------------------------------------------- | | `>` | Größer als | | `>=` | Größer oder gleich | | `<` | Kleiner als | | `<=` | Kleiner oder gleich | | `=` | Gleich | | `!=` bzw. `<>` | Nicht gleich (beide Schreibweisen sind gleichbedeutend) | **Beispiel:** `[A] > [B]` #### Boolesche Operatoren | Operator | Bedeutung | | -------- | --------------------------------------------------------------- | | `&&` | Logisches UND — `TRUE`, wenn beide Operanden `TRUE` sind | | `\|\|` | Logisches ODER — `TRUE`, wenn mindestens ein Operand `TRUE` ist | | `!` | Logische Negation — `TRUE`, wenn der Operand `FALSE` ist | Die Funktionen `UND`, `ODER` und `NICHT` (siehe [Funktionsreferenz](#funktionsreferenz)) sind die Funktionsformen dieser drei Operatoren mit identischer Bedeutung — `[A] && [B]` und `UND([A];[B])` liefern also dasselbe Ergebnis. #### Besonderheiten * Die Groß-/Kleinschreibung von Funktionsnamen spielt keine Rolle. * Bei einer Division durch 0 wird der Wert `UNGÜLTIG` erzeugt, es sei denn, die Funktion `DIVIDIEREN` wird für die Division genutzt. * Leere Zellen haben den Wert `BLANK` (auch: `LEER`). * Eine Formel wird für eine Zelle nur berechnet, wenn mindestens eine der darin referenzierten Kennzahlen (Konstanten zählen nicht) in dieser Zelle einen Wert hat. Sind alle referenzierten Kennzahlen leer, bleibt die Zelle leer. `B=[A]+10` wird also nur in Zellen berechnet, in denen `[A]` einen Wert hat; bei `B=[A]+[C]` genügt es, wenn mindestens eine der beiden Referenzen einen Wert hat. * Wird eine Formel für eine Zelle berechnet, behandeln die Rechenoperatoren (`+`, `-`, `*`, `/`) dabei eine leere Referenz wie `0`. {% hint style="info" %} Jede Funktion kennt einen oder mehrere gültige Namen – teils deutsch, teils englisch (z. B. `RUNDEN` und `ROUND`). Namen sind nicht case-sensitiv (`RUNDEN`, `runden` und `RuNDen` sind gleichbedeutend) und können innerhalb derselben Formel beliebig gemischt werden. Alle gültigen Namen einer Funktion sind jeweils im Feld "Name" in der Funktionsreferenz aufgeführt. {% endhint %} Auch wenn das technisch beliebig gemischt werden kann, empfehlen wir, sich innerhalb eines Modells auf eine einheitliche Schreibweise festzulegen – also durchgängig eine Groß-/Kleinschreibung (z. B. immer Großbuchstaben) und durchgängig entweder deutsche oder englische Funktionsnamen zu verwenden. Das macht Formeln für alle, die später damit arbeiten, deutlich leichter lesbar und wartbar. #### Validierungsregeln * **Konstante Formeln sind nicht erlaubt.** Eine Formel ohne jeden Bezug zu einer anderen Kennzahl (z. B. schlicht `10` oder `-(20+40)`) wird beim Speichern bzw. Hochladen abgelehnt. * **Zyklische Abhängigkeiten sind nicht erlaubt.** Referenzieren sich zwei oder mehr Kennzahlenformeln gegenseitig (z. B. Kennzahl A verwendet `[B]`, Kennzahl B verwendet `[A]`), lässt sich die Formel nicht berechnen. Solche Zyklen werden beim Speichern bzw. Hochladen erkannt und die Änderung mit einem Hinweis auf die betroffenen Kennzahlen abgelehnt. ## Funktionsreferenz * [ABS](#abs) * [COALESCE](#coalesce) * [DIVIDIEREN](#dividieren) * [ISTGÜLTIG](#istgultig) * [ISTLEER](#istleer) * [ISTZEITELEMENTOHNEKINDER](#istzeitelementohnekinder) * [MAXIMUM](#maximum) * [MINIMUM](#minimum) * [MODULO](#modulo) * [NICHT](#nicht) * [ODER](#oder) * [QUOTIENT](#quotient) * [RUNDEN](#runden) * [SUMMEDERKINDER](#summederkinder) * [UND](#und) * [VORZEICHEN](#vorzeichen) * [WENN](#wenn) * [ZEITVERSATZ](#zeitversatz) #### ABS Gibt den Absolutwert des Arguments zurück. Das bedeutet, dass alle negativen Vorzeichen entfernt werden und der positive Wert zurückgegeben wird. **Name:** `ABS` (kein weiterer Name) **Syntax:** ``` ABS() ``` **Beispiel:** `ABS([A])` ergibt `2`, wenn `[A]` den Wert `-2` hat. **Sonderfälle:** * Betrag von UNGÜLTIG = UNGÜLTIG * Betrag von BLANK = BLANK #### COALESCE Gibt den ersten Ausdruck zurück, der nicht als BLANK ausgewertet wird. Wenn alle Ausdrücke als BLANK ausgewertet werden, wird BLANK zurückgegeben. Die Funktion hat mindestens 2 oder mehr Argumente. **Name:** `COALESCE` (kein weiterer Name) **Syntax:** ``` COALESCE(; [;…]) ``` **Beispiel:** Ist `[A]` leer, ergibt `COALESCE([A]; BLANK; 42; 5)` den Wert `42`. #### DIVIDIEREN Führt eine Division aus und gibt ein alternatives Ergebnis oder BLANK bei Division durch 0 zurück. **Name:** `DIVIDIEREN` (auch: `DIVIDE`) **Syntax:** ``` DIVIDIEREN(; [;]) ``` Das alternative Resultat für eine Division durch 0 muss eine Konstante sein. Fehlt die Angabe, so ist bei Division durch 0 das Resultat BLANK. **Beispiele:** * `DIVIDIEREN(6;2;42)` ergibt `3`. * `DIVIDIEREN(6;[A])` ergibt BLANK, wenn `[A]` leer oder 0 ist. * `DIVIDIEREN(6;[A];42)` ergibt `42`, wenn `[A]` leer oder 0 ist. **Sonderfälle:** * UNGÜLTIG / x und x / UNGÜLTIG ergibt UNGÜLTIG * BLANK / BLANK ergibt BLANK * x / BLANK ergibt das alternative Resultat * x ist eine beliebig gültige Zahl #### ISTGÜLTIG Prüft, ob das gegebene Argument eine gültige Zahl ist. **Name:** `ISTGÜLTIG` (auch: `ISVALID`) **Syntax:** ``` ISTGÜLTIG() ``` **Beispiel:** `ISTGÜLTIG(2)` und `ISTGÜLTIG(BLANK)` ergeben `TRUE`, `ISTGÜLTIG(1/0)` ergibt `FALSE`. #### ISTLEER Prüft, ob das gegebene Argument leer ist. **Name:** `ISTLEER` (auch: `ISBLANK`) **Syntax:** ``` ISTLEER() ``` **Beispiel:** `ISTLEER(BLANK)` ergibt `TRUE`, `ISTLEER(2)` ergibt `FALSE`. #### ISTZEITELEMENTOHNEKINDER Die Funktion prüft, ob ein Element der Zeitdimension auf der untersten Hierarchieebene (also ein sogenanntes *Blattelement*) liegt – also keine untergeordneten (Kind-)Elemente besitzt. Sie gibt den Wahrheitswert `TRUE` zurück, wenn das geprüfte Element zur Zeitdimension gehört **und** keine Kinder hat. Andernfalls gibt sie `FALSE` zurück. Dies ist besonders nützlich, wenn bestimmte Berechnungen oder Formeln **nur auf der untersten Ebene** einer Zeitdimension (z. B. einzelnen Monaten) angewendet werden sollen – beispielsweise zur Vermeidung doppelter Aggregationen oder zur gezielten Steuerung der Berechnungslogik innerhalb hierarchischer Zeitstrukturen. **Name:** `ISTZEITELEMENTOHNEKINDER` (auch: `ISTIMEELEMENTWITHOUTCHILDREN`) **Syntax:** ``` ISTZEITELEMENTOHNEKINDER() ``` **Besonderheiten:** * Die Funktion benötigt **keine Argumente**. * Die Funktion **kann nur für innere Formeln** verwendet werden (Formeln für aggregierte Ebenen). * Sie kann ausschließlich im Kontext einer Dimension mit der Rollenbezeichnung „Zeit“ verwendet werden. * In Formularformeln steht die Funktion nicht zur Verfügung. * Die Funktion eignet sich besonders für Bedingungen innerhalb von `WENN`-Formeln oder zur Kombination mit `UND`, `ODER`, `NICHT`, um gezielt die Berechnungsebene zu kontrollieren. **Beispiel:** ``` WENN(ISTZEITELEMENTOHNEKINDER(); [WERT]; BLANK) ``` → In diesem Beispiel wird der Wert `[WERT]` nur auf untersten Zeit-Elementen berechnet. Für alle übergeordneten Elemente (z. B. Quartale oder Jahre) bleibt das Ergebnis `BLANK`. #### MAXIMUM Gibt das Maximum der gegebenen Argumente zurück. **Name:** `MAXIMUM` (auch: `MAX`) **Syntax:** ``` MAXIMUM( [;;…]) ``` **Beispiel:** `MAXIMUM(BLANK;-42;-2)` ergibt `-2`. **Sonderfälle:** * Leere Argumente werden ignoriert. * Ist eines der Argumente UNGÜLTIG, ist auch das Ergebnis UNGÜLTIG (z. B. ergibt `MAXIMUM(2;1/0)` den Wert UNGÜLTIG). #### MINIMUM Gibt das Minimum der gegebenen Argumente zurück. **Name:** `MINIMUM` (auch: `MIN`) **Syntax:** ``` MINIMUM( [;;…]) ``` **Beispiel:** `MINIMUM(BLANK;42;2)` ergibt `2`. **Sonderfälle:** * Leere Argumente werden ignoriert. * Ist eines der Argumente UNGÜLTIG, ist auch das Ergebnis UNGÜLTIG (z. B. ergibt `MINIMUM(2;1/0)` den Wert UNGÜLTIG). #### MODULO Gibt den Rest einer ganzzahligen Division zurück. **Name:** `MODULO` (auch: `MOD`, `REST`) **Syntax:** ``` MODULO(; ) ``` **Beispiel:** `15 : 12 = 1`, Rest `3` — also ergibt `MODULO(15;12)` den Wert `3`.

Beispiel für die Formel MODULO([B];[A])

#### NICHT Funktionale Version von `!`. Diese Funktion ermöglicht die Negation einer Bedingung in einer Funktionsform. **Name:** `NICHT` (auch: `NOT`) **Syntax:** ``` NICHT() ``` **Beispiel:** `NICHT(1 > 0)` ergibt `FALSE`, `NICHT(2 > 3)` ergibt `TRUE`. #### ODER Funktionale Version von `||`. Diese Funktion ermöglicht es, mehrere alternative Bedingungen in einer Funktionsform zu kombinieren. **Name:** `ODER` (auch: `OR`) **Syntax:** ``` ODER(; ) ``` **Beispiel:** `ODER(1 > 0; 2 != 2)` ergibt `TRUE`, `ODER(1 > 5; 2 != 2)` ergibt `FALSE`. #### QUOTIENT Bildet den Quotienten aus Dividend und Divisor. Zurückgegeben wird immer eine Ganzzahl. **Name:** `QUOTIENT` (kein weiterer Name) **Syntax:** ``` QUOTIENT(; ) ``` **Beispiel:** `QUOTIENT(5;3)` ergibt `1`, da die Nachkommastellen entfallen. #### RUNDEN Rundet eine Zahl auf die angegebene Anzahl von Stellen. **Name:** `RUNDEN` (auch: `ROUND`) **Syntax:** ``` RUNDEN( [; ]) ``` Die Anzahl der Stellen ist die Anzahl der Dezimalstellen, auf die gerundet werden soll. Bei einem negativen Wert werden Stellen links vom Dezimaltrennzeichen gerundet. Beim Wert 0 oder wenn die Anzahl der Stellen nicht angegeben wird, wird auf die nächste ganze Zahl gerundet. Die Anzahl Stellen muss eine Konstante sein. **Beispiele:** * `RUNDEN([A])` ergibt `2`, wenn `[A]` den Wert `1,52` hat. * `RUNDEN([A]; -3)` ergibt `1000`, wenn `[A]` den Wert `995` hat. * `RUNDEN([A]; 3)` ergibt `9,556`, wenn `[A]` den Wert `9,5557` hat. #### SUMMEDERKINDER Summiert die Werte der Kinder des aktuellen Elements. Dies ist besonders nützlich für hierarchische Berechnungen, bei denen die Gesamtsumme aus den Werten der untergeordneten Elemente ermittelt werden muss. **Name:** `SUMMEDERKINDER` (auch: `SUMOFCHILDREN`, `SUMMEKINDER`, `SUMCHILDREN`) **Syntax:** ``` SUMMEDERKINDER() ``` **Beispiel:** Hat Element `A` die Kinder `B` und `C` mit den Werten `3` und `2`, ergibt `SUMMEDERKINDER()` für `A` den Wert `5`. Für `C` selbst (ohne Kinder) ergibt sich BLANK. **Sonderfälle:** * Hat das Element keine Kinder, ergibt sich BLANK. * Hat eines der Kinder den Wert UNGÜLTIG, ist auch das Ergebnis UNGÜLTIG. * In Formularformeln steht die Funktion nicht zur Verfügung. #### UND Funktionale Version von `&&`. Diese Funktion ermöglicht es, zwei Bedingungen in einer Funktionsform zu kombinieren. **Name:** `UND` (auch: `AND`) **Syntax:** ``` UND(; ) ``` **Beispiel:** `UND(1 > 0; 2 = 2)` ergibt `TRUE`, `UND(1 > 0; 2 != 2)` ergibt `FALSE`. #### VORZEICHEN Gibt das Vorzeichen des gegebenen Wertes zurück. Die Funktion gibt -1, 0 oder 1 zurück, je nachdem, ob der Wert negativ, null oder positiv ist. **Name:** `VORZEICHEN` (auch: `SIGN`, `SIGNUM`) **Syntax:** ``` VORZEICHEN() ``` **Beispiel:** `VORZEICHEN(-42)` ergibt `-1`, `VORZEICHEN(42)` ergibt `1` und `VORZEICHEN(0)` ergibt `0`. **Sonderfälle:** * Betrag von UNGÜLTIG = UNGÜLTIG * Betrag von BLANK = BLANK #### WENN Prüft eine Bedingung und gibt einen Wert zurück, wenn diese TRUE ist; andernfalls wird ein zweiter Wert zurückgegeben. **Name:** `WENN` (auch: `IF`) **Syntax:** ``` WENN(;;) ``` Die Bedingung besteht meist aus einem Vergleich zweier Werte über einen [Vergleichsoperator](#vergleichsoperatoren) (z. B. `[A] > [B]`). **Beispiel:** `WENN(3 > 1; 4; 2)` ergibt `4`, `WENN(3 < 1; 4; 2)` ergibt `2`. **Sonderfälle:** Ist die Bedingung nicht auswertbar (z. B. weil einer der verglichenen Werte UNGÜLTIG ist), ist auch das Ergebnis der WENN-Funktion UNGÜLTIG. #### ZEITVERSATZ Diese Funktion ermöglicht es, in einer Kennzahlenformel auf ein Vorgängerelement der Zeit-Dimension zuzugreifen. **Name:** `ZEITVERSATZ` (auch: `TIMEOFFSET`) **Syntax:** ``` ZEITVERSATZ(;) ``` Voraussetzung ist die Definition einer Dimension mit der Dimensionsrolle Zeit. Typischerweise sind dies die Monate. Die Funktion wirkt nur auf den Blättern (unterste Ebene) dieser Dimension. Das `` muss ein Kennzahlschlüssel sein, ein Formelausdruck ist nicht erlaubt. In Formularformeln steht die Funktion nicht zur Verfügung. Der `` ist eine negative Konstante und bezeichnet die Schrittweite, um das Vorgängerelement ermitteln zu können. Das Vorgängerelement ist das in der Reihenfolge der Dimensionselemente relativ um die angegebene Schrittweite weiter oben liegende Blatt. Elemente, die keine Blätter sind, werden dabei nicht mitgezählt. Die Funktion wirkt gemäß der Reihenfolge der Dimensionselemente nicht auf dem 1. Blatt, welches aber auch nicht eingabefähig ist. Deshalb muss der Startwert in einer weiteren Kennzahl eingegeben werden. Eine Formel für eine Kennzahl x kann in der ZEITVERSATZ-Funktion ausnahmsweise die Zielkennzahl x auch als Argument verwenden (z. B. im Sinne von `[ANZAHL_KUNDEN] = [KUNDEN_ZUGANG] + ZEITVERSATZ([ANZAHL_KUNDEN];-1)`). **Beispiel:** Enthält der Datenwürfel für Kennzahl `A` im Monat Januar den Wert `42,42`, ergibt die Formel `ZEITVERSATZ([A];-1) + 1` für eine Kennzahl `B` im Monat Februar den Wert `43,42`.