> For the complete documentation index, see [llms.txt](https://docs.videc.de/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.videc.de/acron-9.3/intro/funktionen/funk_logik.md).

# Funktionen Logik/Binär

Die Gruppe logische und binäre Funktionen enthält Funktionen, mit denen Sie Daten binär verknüpfen und bearbeiten können. In der Gruppe finden Sie die folgenden Funktionen:

In der Tabelle finden Sie in der ersten Spalte den Namen der Funktion, so wie Sie ihn in einem Ausdruck eingeben. In der zweiten Spalte finden Sie die Datentypen des oder der Argumente und in der dritten Spalte steht der Datentyp des Rückgabewerts der Funktion.

| Funktion                         | Argumente          | Rückgabewert |
| -------------------------------- | ------------------ | ------------ |
| [BAnd](#func_band)               | (ZAHL, ZAHL)       | ZAHL         |
| [BOr](#func_bor)                 | (ZAHL, ZAHL)       | ZAHL         |
| [BXor](#func_bxor)               | (ZAHL, ZAHL)       | ZAHL         |
| [Cond](#func_cond)               | (BOOL, ALLE, ALLE) | ALLE         |
| [If](#func_if)                   | (BOOL, ALLE, ALLE) | ALLE         |
| [IsEven](#func_iseven)           | (ZAHL)             | BOOL         |
| [IsNoValid](#func_isnovalid)     | (ZAHL)             | BOOL         |
| [IsOdd](#func_isodd)             | (ZAHL)             | BOOL         |
| [MakeDWord](#func_makedword)     | (ZAHL, ZAHL)       | ZAHL         |
| [MakeSDWord](#func_makesdword)   | (ZAHL, ZAHL)       | ZAHL         |
| [RotateLeft](#func_rotateleft)   | (ZAHL, ZAHL)       | ZAHL         |
| [RotateRight](#func_rotateright) | (ZAHL, ZAHL)       | ZAHL         |
| [ShiftLeft](#func_shiftleft)     | (ZAHL, ZAHL)       | ZAHL         |
| [ShiftRight](#func_shiftright)   | (ZAHL, ZAHL)       | ZAHL         |

Eventuell sind nicht alle Funktionen dieser Gruppe in der von Ihnen verwendeten Anwendung verfügbar. Die Anwendung kann einzelne Funktionen beziehungsweise ganze Funktionsgruppen innerhalb des Formeleditors deaktivieren. Dies sind normalerweise Funktionen, die innerhalb der Anwendung nicht benötigt werden, da z.B. ein bestimmter Datentyp nicht verwendet wird.

## Funktion BAnd <a href="#func_band" id="func_band"></a>

|               |                                                                                                                                                                                         |
| ------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Syntax:       | ZAHL BAnd (ZAHL, ZAHL)                                                                                                                                                                  |
| Parameter:    | <ul><li>1. zu verknüpfender Wert.</li><li>2. zu verknüpfender Wert.</li></ul>                                                                                                           |
| Rückgabewert: | Logische UND Verknüpfung der beiden Argumente.                                                                                                                                          |
| Beschreibung: | <p>Verknüpft die beiden als Argumente übergebenen Zahlen bitweise binär UND.</p><p>Eine gebrochene Zahl als Argument wird vor der Berechnung auf die nächste ganze Zahl abgerundet.</p> |
| Beispiel:     | <p>BAnd (1,1) = 1</p><p>BAnd (999, 200) = 192</p>                                                                                                                                       |
| Siehe auch:   | [Funktion BOr](#func_bor), [Funktion BXor](#func_bxor)                                                                                                                                  |

## Funktion BOr <a href="#func_bor" id="func_bor"></a>

|               |                                                                                                                                                                                          |
| ------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Syntax:       | ZAHL BOr (ZAHL, ZAHL)                                                                                                                                                                    |
| Parameter:    | <ul><li>1. zu verknüpfender Wert.</li><li>2. zu verknüpfender Wert.</li></ul>                                                                                                            |
| Rückgabewert: | Logische ODER Verknüpfung der beiden Argumente.                                                                                                                                          |
| Beschreibung: | <p>Verknüpft die beiden als Argumente übergebenen Zahlen bitweise binär ODER.</p><p>Eine gebrochene Zahl als Argument wird vor der Berechnung auf die nächste ganze Zahl abgerundet.</p> |
| Beispiel:     | <p>BOr (1,1) = 1</p><p>BOr (999, 200) = 1007</p>                                                                                                                                         |
| Siehe auch:   | [Funktion BAnd](#func_band), [Funktion BXor](#func_bxor)                                                                                                                                 |

## Funktion BXOr <a href="#func_bxor" id="func_bxor"></a>

|               |                                                                                                                                                                                                   |
| ------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Syntax:       | ZAHL BXOr (ZAHL, ZAHL)                                                                                                                                                                            |
| Parameter:    | <ul><li>1. zu verknüpfender Wert.</li><li>2. zu verknüpfender Wert.</li></ul>                                                                                                                     |
| Rückgabewert: | Logische exklusiv ODER Verknüpfung der beiden Argumente.                                                                                                                                          |
| Beschreibung: | <p>Verknüpft die beiden als Argumente übergebenen Zahlen bitweise binär exklusiv ODER.</p><p>Eine gebrochene Zahl als Argument wird vor der Berechnung auf die nächste ganze Zahl abgerundet.</p> |
| Beispiel:     | <p>BXOr (1,1) = 0</p><p>BXOr (999, 200) = 815</p>                                                                                                                                                 |
| Siehe auch:   | [Funktion BAnd](#func_band), [Funktion BOr](#func_bor)                                                                                                                                            |

## Funktion Cond <a href="#func_cond" id="func_cond"></a>

|               |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| ------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Syntax:       | ALLE Cond (BOOL, ALLE \[, ALLE])                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| Parameter:    | <ul><li>Bedingung</li><li>Wert für den Fall, dass die Bedingung TRUE ist.</li><li>Wert für den Fall, dass die Bedingung FALSE ist.</li></ul><p>Die Datentypen für das 2. und das 3. Argument müssen identisch sein.</p>                                                                                                                                                                                                                                                                  |
| Rückgabewert: | Liefert abhängig von der Bedingung den Wert des 2. oder des 3. Arguments.                                                                                                                                                                                                                                                                                                                                                                                                                |
| Beschreibung: | <p>Die Funktion erlaubt das Formulieren beliebiger Bedingungen. Das erste Argument ist ein logischer Ausdruck, dessen Inhalt die Ausgabe der Funktion steuert.</p><p>Enthält das erste Argument den Wert TRUE, liefert die Funktion den Wert des 2. Arguments. Ist das erste Argument FALSE, liefert die Funktion den Wert des 3. Arguments.</p><p>Wird das 3. Argument nicht angegeben, liefert die Funktion als Standardwert eine 0, wenn die Bedingung nicht erfüllt (FALSE) ist.</p> |
| Verweise:     | [Funktion If](#func_if)                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |

## Funktion If <a href="#func_if" id="func_if"></a>

|               |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| ------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Syntax:       | ALLE If (BOOL, ALLE \[, ALLE])                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| Parameter:    | <ul><li>Bedingung</li><li>Wert für den Fall, dass die Bedingung TRUE ist.</li><li>Wert für den Fall, dass die Bedingung FALSE ist.</li></ul><p>Die Datentypen für das 2. und das 3. Argument müssen identisch sein.</p>                                                                                                                                                                                                                                                                  |
| Rückgabewert: | Liefert abhängig von der Bedingung den Wert des 2. oder des 3. Arguments.                                                                                                                                                                                                                                                                                                                                                                                                                |
| Beschreibung: | <p>Die Funktion erlaubt das Formulieren beliebiger Bedingungen. Das erste Argument ist ein logischer Ausdruck, dessen Inhalt die Ausgabe der Funktion steuert.</p><p>Enthält das erste Argument den Wert TRUE, liefert die Funktion den Wert des 2. Arguments. Ist das erste Argument FALSE, liefert die Funktion den Wert des 3. Arguments.</p><p>Wird das 3. Argument nicht angegeben, liefert die Funktion als Standardwert eine 0, wenn die Bedingung nicht erfüllt (FALSE) ist.</p> |
| Siehe auch:   | [Funktion Cond](#func_cond)                                                                                                                                                                                                                                                                                                                                                                                                                                                              |

## Funktion IsEven <a href="#func_iseven" id="func_iseven"></a>

|               |                                                                                                                                                                       |
| ------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Syntax:       | BOOL IsEven (ZAHL)                                                                                                                                                    |
| Parameter:    | <ul><li>Der zu überprüfende Wert.</li></ul>                                                                                                                           |
| Rückgabewert: | TRUE, wenn der übergebene Wert gerade, d.h. glatt durch 2 teilbar ist.                                                                                                |
| Beschreibung: | Die Funktion prüft, ob der übergebene Wert gerade, d.h. glatt durch 2 teilbar ist. Besitzt der übergebene Wert Nachkommastellen, wird er vor der Prüfung aufgerundet. |
| Beispiel:     | <p>IsEven (3) = FALSE</p><p>IsEven (1200) = TRUE</p>                                                                                                                  |
| Siehe auch:   | [Funktion IsOdd](#func_isodd)                                                                                                                                         |

## Funktion IsNoValid <a href="#func_isnovalid" id="func_isnovalid"></a>

|               |                                                                                                           |
| ------------- | --------------------------------------------------------------------------------------------------------- |
| Syntax:       | BOOL IsNoValid (ZAHL)                                                                                     |
| Parameter:    | <ul><li>Der zu überprüfende Wert.</li></ul>                                                               |
| Rückgabewert: | Wenn ein Überlauf aufgetreten oder ein ungültiger Wert vorliegt TRUE, andernfalls FALSE.                  |
| Beschreibung: | Prüft, ob bei einer Berechnung ein Überlauf aufgetreten oder eine Variable einen ungültigen Wert besitzt. |
| Siehe auch:   | [Funktion NoValid](/acron-9.3/intro/funktionen/funk_variablen.md#func_novalid)                            |

## Funktion IsOdd <a href="#func_isodd" id="func_isodd"></a>

|               |                                                                                                                                                                         |
| ------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Syntax:       | BOOL IsOdd (ZAHL)                                                                                                                                                       |
| Parameter:    | <ul><li>Der zu überprüfende Wert.</li></ul>                                                                                                                             |
| Rückgabewert: | TRUE, wenn der übergebene Wert ungerade, d.h. nicht durch 2 teilbar ist.                                                                                                |
| Beschreibung: | Die Funktion prüft, ob der übergebene Wert ungerade, d.h. nicht durch 2 teilbar ist. Besitzt der übergebene Wert Nachkommastellen, wird er vor der Prüfung aufgerundet. |
| Beispiel:     | <p>IsOdd (3) = TRUE</p><p>IsOdd (1200) = FALSE</p>                                                                                                                      |
| Siehe auch:   | [Funktion IsEven](#func_iseven)                                                                                                                                         |

## Funktion MakeDWord <a href="#func_makedword" id="func_makedword"></a>

|               |                                                                                                                                                                                                                                                                                                             |
| ------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Syntax:       | ZAHL MakeDWord (ZAHL, ZAHL)                                                                                                                                                                                                                                                                                 |
| Parameter:    | <ul><li>HIGH Word des resultierenden 32 Bit Wertes.</li><li>LOW Word des resultierenden 32 Bit Wertes.</li></ul>                                                                                                                                                                                            |
| Rückgabewert: | 32 Bit Verknüpfung der beiden Argumente.                                                                                                                                                                                                                                                                    |
| Beschreibung: | <p>Die Funktion verknüpft die beiden 16 Bit Argumente zu einer 32 Bit Zahl. Dazu wird der Inhalt des 1. Arguments um 16 Bit nach links verschoben und logisch UND mit dem 2. Argument verknüpft.</p><p>Eine gebrochene Zahl als Argument wird vor der Berechnung auf die nächste ganze Zahl abgerundet.</p> |
| Beispiel:     | <p>MakeDWord (1, 0) = 65536</p><p>MakeDWord (1,1) = 65537</p>                                                                                                                                                                                                                                               |
| Siehe auch:   | [Funktion MakeSDWord](#func_makesdword)                                                                                                                                                                                                                                                                     |

## Funktion MakeSDWord <a href="#func_makesdword" id="func_makesdword"></a>

|               |                                                                                                                                                                                                                                                                                                                                                               |
| ------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Syntax:       | ZAHL MakeSDWord (ZAHL, ZAHL)                                                                                                                                                                                                                                                                                                                                  |
| Parameter:    | <ul><li>HIGH Word des resultierenden 32 Bit Wertes.</li><li>LOW Word des resultierenden 32 Bit Wertes.</li></ul>                                                                                                                                                                                                                                              |
| Rückgabewert: | 32 Bit Verknüpfung der beiden Argumente.                                                                                                                                                                                                                                                                                                                      |
| Beschreibung: | <p>Die Funktion verknüpft die beiden 16 Bit Argumente zu einer 32 Bit Zahl. Dazu wird der Inhalt des 1. Arguments um 16 Bit nach links verschoben und logisch UND mit dem 2. Argument verknüpft. Bei der Verknüpfung wird das Vorzeichen beachtet.</p><p>Eine gebrochene Zahl als Argument wird vor der Berechnung auf die nächste ganze Zahl abgerundet.</p> |
| Beispiel:     | <p>MakeSDWord (1, 0) = 65536</p><p>MakeSDWord (1,1) = 65537</p>                                                                                                                                                                                                                                                                                               |
| Siehe auch:   | [Funktion MakeDWord](#func_makedword)                                                                                                                                                                                                                                                                                                                         |

## Funktion RotateLeft <a href="#func_rotateleft" id="func_rotateleft"></a>

|               |                                                                                                                                                                                                                                                                                                                                        |
| ------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Syntax:       | ZAHL RotateLeft (ZAHL, Stellen)                                                                                                                                                                                                                                                                                                        |
| Parameter:    | <ul><li>Zu rotierender Wert</li><li>Anzahl Stellen, um die rotiert wird.</li></ul>                                                                                                                                                                                                                                                     |
| Rückgabewert: | Wert, nachdem die Rotation ausgeführt wurde.                                                                                                                                                                                                                                                                                           |
| Beschreibung: | <p>Die Funktion rotiert die Bits aus dem 1. Argument um die im 2. Argument angegebene Anzahl Stellen nach links. Bits, die links aus der Zahl herausgeschoben werden, werden auf der rechten Seite wieder herein geschoben.</p><p>Eine gebrochene Zahl als Argument wird vor der Berechnung auf die nächste ganze Zahl abgerundet.</p> |
| Beispiel:     | <p>RotateLeft (1, 2) = 4</p><p>RotateLeft (0x1000, 20) = 0x00000001</p>                                                                                                                                                                                                                                                                |
| Siehe auch:   | [Funktion RotateRight](#func_rotateright), [Funktion ShiftLeft](#func_shiftleft)                                                                                                                                                                                                                                                       |

## Funktion RotateRight <a href="#func_rotateright" id="func_rotateright"></a>

|               |                                                                                                                                                                                                                                                                                                                                         |
| ------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Syntax:       | ZAHL RotateRight (ZAHL, Stellen)                                                                                                                                                                                                                                                                                                        |
| Parameter:    | <ul><li>Zu rotierender Wert</li><li>Anzahl Stellen, um die rotiert wird.</li></ul>                                                                                                                                                                                                                                                      |
| Rückgabewert: | Wert, nachdem die Rotation ausgeführt wurde.                                                                                                                                                                                                                                                                                            |
| Beschreibung: | <p>Die Funktion rotiert die Bits aus dem 1. Argument um die im 2. Argument angegebene Anzahl Stellen nach rechts. Bits, die rechts aus der Zahl herausgeschoben werden, werden auf der linken Seite wieder herein geschoben.</p><p>Eine gebrochene Zahl als Argument wird vor der Berechnung auf die nächste ganze Zahl abgerundet.</p> |
| Beispiel:     | <p>RotateRight (1, 2) = 0x40000000</p><p>RotateRight (0x1000, 20) = 0x01000000</p>                                                                                                                                                                                                                                                      |
| Siehe auch:   | [Funktion RotateLeft](#func_rotateleft), [Funktion ShiftRight](#func_shiftright)                                                                                                                                                                                                                                                        |

## Funktion ShiftLeft <a href="#func_shiftleft" id="func_shiftleft"></a>

|               |                                                                                                                                                                                                                                                                                |
| ------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| Syntax:       | ZAHL ShiftLeft (ZAHL, Stellen)                                                                                                                                                                                                                                                 |
| Parameter:    | <ul><li>Zu verschiebender Wert</li><li>Anzahl Stellen, um die verschoben wird.</li></ul>                                                                                                                                                                                       |
| Rückgabewert: | Wert, nachdem die Verschiebung ausgeführt wurde.                                                                                                                                                                                                                               |
| Beschreibung: | <p>Die Funktion schiebt die Bits aus dem 1. Argument um die im 2. Argument angegebene Anzahl Stellen nach links. Auf der rechten Seite werden Nullen nachgeschoben.</p><p>Eine gebrochene Zahl als Argument wird vor der Berechnung auf die nächste ganze Zahl abgerundet.</p> |
| Beispiel:     | <p>ShiftLeft (1, 2) = 4</p><p>ShiftLeft (0x1000, 20) = 0x00000000</p>                                                                                                                                                                                                          |
| Siehe auch:   | [Funktion ShiftRight](#func_shiftright), [Funktion RotateLeft](#func_rotateleft)                                                                                                                                                                                               |

## Funktion ShiftRight <a href="#func_shiftright" id="func_shiftright"></a>

|               |                                                                                                                                                                                                                                                                                |
| ------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| Syntax:       | ZAHL ShiftRight (ZAHL, Stellen)                                                                                                                                                                                                                                                |
| Parameter:    | <ul><li>Zu verschiebender Wert</li><li>Anzahl Stellen, um die verschoben wird.</li></ul>                                                                                                                                                                                       |
| Rückgabewert: | Wert, nachdem die Verschiebung ausgeführt wurde.                                                                                                                                                                                                                               |
| Beschreibung: | <p>Die Funktion schiebt die Bits aus dem 1. Argument um die im 2. Argument angegebene Anzahl Stellen nach rechts. Auf der linken Seite werden Nullen nachgeschoben.</p><p>Eine gebrochene Zahl als Argument wird vor der Berechnung auf die nächste ganze Zahl abgerundet.</p> |
| Beispiel:     | <p>ShiftRight (1,2) = 0</p><p>ShiftRight (0x1000, 20) = 0x00000000</p>                                                                                                                                                                                                         |
| Siehe auch:   | [Funktion ShiftLeft](#func_shiftleft), [Funktion RotateRight](#func_rotateright)                                                                                                                                                                                               |


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## 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.videc.de/acron-9.3/intro/funktionen/funk_logik.md?ask=<question>
```

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.