# Logik

**Logik**, genauer **Bedingungslogik** ermöglicht die Angabe einer Aktion oder einer Gruppe von Aktionen unter Verwendung einer Prüfung. Die Auswertung der Prüfung ergibt einen booleschen Wert für `True` oder `False`, der zur Steuerung des Programmablaufs verwendet werden kann.

### Boolesche Werte

Numerische Variablen können für eine Vielzahl unterschiedlicher Zahlen stehen. Boolesche Variablen hingegen können nur zwei Werte annehmen, die als True oder False, Ja oder Nein, 1 oder 0 wiedergegeben werden. Booleschen Operationen werden wegen ihrer begrenzten Möglichkeiten nur selten zum Durchführen von Berechnungen verwendet.

### Bedingungsanweisungen

Die "If"-Anweisung ist ein wichtiges Konzept in der Programmierung: "Wenn *dies* zutrifft (True), dann geschieht *das*, andernfalls geschieht *etwas anderes*. Die aus der Anweisung resultierende Aktion wird durch einen booleschen Wert gesteuert. In Dynamo stehen mehrere Möglichkeiten zum Definieren von If-Anweisungen zur Verfügung:

| Symbol                                                                                                                                                              | Name (Syntax)            | Eingaben          | Ausgaben |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------ | ----------------- | -------- |
| ![](https://641824696-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNHcLDVpyqI8KoM5vfcD1%2Fuploads%2FHMnXlqFCliX9aLLZTAiE%2FIf.jpg?alt=media) | Wenn (**If**)            | test, true, false | result   |
|                                                                                                                                                                     | Codeblock (**(x?y:z);**) | x? y, z           | result   |

Die folgenden kurzen Beispiele zeigen die Funktionsweise dieser drei Blöcke in der If-Bedingungsanweisung.

In dieser Abbildung wurde für *Boolean* die Option *true* eingestellt, d. h., das Ergebnis ist die Zeichenfolge: *"this is the result if true".* Die drei möglichen Blöcke, mit deren Hilfe die *If*-Anweisung erstellt werden kann, funktionieren hier auf dieselbe Weise.

!

Auch in diesem Fall funktionieren die Blöcke auf dieselbe Weise. Wenn Sie den *Boolean*-Wert in *False* ändern, wird als Ergebnis die Zahl *Pi* ausgegeben, wie in der ursprünglichen *If*-Anweisung festgelegt.

!

## Übung: Logik und Geometrie

> Laden Sie die Beispieldatei herunter, indem Sie auf den folgenden Link klicken.
>
> Eine vollständige Liste der Beispieldateien finden Sie im Anhang.

### Teil I: Filtern einer Liste

1. In diesem Beispiel teilen Sie eine Liste von Zahlen in eine Liste mit geraden und eine Liste ungeraden Zahlen auf.

!

> a. **Range**: Definieren Sie im Ansichtsbereich einen Zahlenbereich.
>
> b. **Number**: Fügen Sie im Ansichtsbereich drei Number-Blöcke ein. Legen Sie in diesen Blöcken die folgenden Werte fest: *0.0* für *start*, *10.0* für *end* und *1.0* für *step*.
>
> c. **Ausgabe**: Die Ausgabe zeigt eine Liste mit 11 Zahlen von 0-10.
>
> d. **Modulo (%)**: Verbinden Sie **Number Range** mit *x* und *2.0* mit *y*. Mit dieser Funktion wird für jede Zahl aus der Liste der Rest bei Division durch 2 berechnet. Die Ausgabe für diese Liste ist eine Liste, die abwechselnd die Werte 0 und 1 enthält.
>
> e. **Gleichheitsprüfung (==)**: Fügen Sie im Ansichtsbereich einen Block für die Gleichheitsprüfung hinzu. Verbinden Sie die Ausgabe des *Modulo*-Blocks mit der *x*-Eingabe und *0.0* mit der *y*-Eingabe.
>
> f. **Watch**: Die Gleichheitsprüfung gibt eine Liste aus, die abwechselnd die Werte true und false enthält. Mithilfe dieser Werte werden die Einträge aus der Zahlenliste eingeordnet. Dabei steht *0* (bzw. *true*) für gerade und (*1* bzw. *false*) für ungerade Zahlen.
>
> g. **List.FilterByBoolMask**: Dieser Block filtert die Werte anhand der eingegebenen Booleschen Operation in zwei Listen. Verbinden Sie den ursprünglichen *Number Range* mit der *list*-Eingabe und die Ausgabe von *Equality Test* mit der *mask*-Eingabe. Die *in*-Ausgabe enthält die true-Werte, die *out*-Ausgabe die false-Werte.
>
> h. **Watch**: Als Ergebnis erhalten Sie eine Liste mit geraden und eine Liste mit ungeraden Zahlen. Damit haben Sie mithilfe logischer Operatoren Listen anhand eines Musters aufgeteilt.

### Teil II: Von der Logik zur Geometrie

In diesem Schritt wenden Sie die in der ersten Übung erstellte Logik auf einen Modellierungsvorgang an.

2\. Beginnen Sie mit den Blöcken aus der letzten Übung. Die einzigen Ausnahmen (zusätzlich zum Ändern des Formats) sind:

!

> a. Verwenden Sie einen **Sequence**-Block mit diesen Eingabewerten.
>
> b. Die in-Listeneingabe für **List.FilterByBoolMask** wurde entfernt. Diese Blöcke werden momentan nicht benötigt, kommen aber weiter unten in dieser Übung zum Einsatz.

3\. Erstellen Sie zunächst eine separate Gruppe von Diagrammen, wie in der Abbildung oben gezeigt. Diese Gruppe von Blöcken stellt eine parametrische Gleichung zum Definieren einer Sinuskurve dar. Einige Hinweise:

!

> a. Der erste **Number Slider**-Block repräsentiert die Frequenz der Welle. Er sollte einen Mindestwert von 1, einen Höchstwert von 4 und eine Schrittweite von 0.01 haben.
>
> b. Der zweite **Number Slider**-Block repräsentiert die Amplitude der Welle. Er sollte einen Mindestwert von 0, einen Höchstwert von 1 und eine Schrittweite von 0.01 haben.
>
> c. **PolyCurve.ByPoints**: Indem Sie das oben gezeigte Blockdiagramm kopieren, erhalten im Ansichtsfenster der Dynamo-Vorschau eine Sinuskurve.

Für die Eingaben gilt hier folgende Regel: Verwenden Sie Zahlenblöcke für statische und Schieberegler für veränderliche Eigenschaften. Der anfangs definierte ursprüngliche Zahlenbereich soll erhalten bleiben. Für die Sinuskurve, die hier erstellt werden soll, wird jedoch mehr Flexibilität benötigt. Mithilfe dieser Schieberegler können Sie die Frequenz und Amplitude der Kurve ändern.

!

4\. Die Schritte dieser Definition werden hier nicht nacheinander beschrieben. Hier wird zunächst das Endergebnis gezeigt, um eine Vorstellung der fertigen Geometrie zu vermitteln. Die ersten beiden Schritte wurden separat durchgeführt und müssen jetzt zusammengeführt werden. Die Position der reißverschlussähnlichen Bauteile soll durch die zugrunde liegende Sinuskurve gesteuert werden, wobei mithilfe der True/False-Logik abwechselnd große und kleine Quader eingefügt werden.

!

> a. **Math.RemapRange**: Erstellen Sie aus der in Schritt 02 erstellten Zahlenfolge eine neue Zahlenfolge, indem Sie den Bereich neu zuordnen. In Schritt 01 wurden Zahlen von 0 – 100 festgelegt. Diese Zahlen liegen zwischen 0 und 1, wie mithilfe der Eingaben *newMin* und *newMax* festgelegt.

5\. Erstellen Sie einen **Curve.PointAtParameter**-Block, und verbinden Sie dann die **Math.RemapRange**-Ausgabe aus Schritt 04 als *param*-Eingabe.

!

Mithilfe dieses Schritts erstellen Sie Punkte entlang der Kurve. Die Zahlen mussten dem Bereich 0 bis 1 neu zugeordnet werden, da als Eingabe für *param* Werte in diesem Bereich verlangt werden. Der Wert *0* steht für den Startpunkt, der Wert *1* für die Endpunkte. Die Auswertung aller dazwischen liegenden Zahlen ergibt Werte im Bereich *\[0,1]*.

6\. Verbinden Sie die Ausgabe von **Curve.PointAtParameter** mit **List.FilterByBoolMask**, um die Liste der ungeraden und geraden Indizes zu trennen.

!

> a. **List.FilterByBoolMask**: Verbinden Sie **Curve.PointAtParameter** aus dem vorigen Schritt mit der *list*-Eingabe.
>
> b. **Watch**: Die Watch-Blöcke für *in* und *out* zeigen, dass zwei Listen für gerade bzw. ungerade Indizes erstellt wurden. Diese Punkte sind auf dieselbe Weise entlang der Kurve angeordnet, wie im folgenden Schritt gezeigt.

7\. Als Nächstes verwenden Sie das Ausgabeergebnis von **List.FilterByBoolMask** in Schritt 05, um Geometrien mit Größen entsprechend ihrer Indizes zu generieren.

**Cuboid.ByLengths**: Stellen Sie die in der Abbildung oben gezeigten Verbindungen wieder her, um eine reißverschlussähnliche Struktur entlang der Kurve zu erhalten. Sie erstellen hier einfache Quader, deren Größe jeweils durch ihren auf der Kurve liegenden Mittelpunkt definiert wird. Die Logik der Aufteilung in gerade und ungerade Werte wird damit im Modell deutlich.

!

> a. Liste der Quader mit geraden Indizes.
>
> b. Liste der Quader mit ungeraden Indizes.

Geschafft! Sie haben soeben einen Prozess zum Definieren der Geometriebemaßungen entsprechend der in dieser Übung dargestellten logischen Operation programmiert.