Arithmetische Operatoren - Cinderella Dokumentation
Description: The user's guide to the Interactive Geometry Software Cinderella

Zum Inhalt

# Arithmetische Operatoren

Der folgende Abschnitt fasst alle Funktionen und Operatoren zusammen, die auf Zahlen angewendet werden können. Es gibt auch viele weitere mathematische Operationen, die in den Abschnitten Vektoren und Matrizen, Geometrische Operatoren und Funktionsplot zu finden sind.

### Infix-Operatoren

Die elementaren mathematischen Operatoren +, -, *, /, ^ sind auf einfache Weise zugänglich. Sie können auf Zahlen und Listen angewendet werden. Ihre jeweilige Bedeutung hängt vom Typ der Objekte ab, auf die sie angewendet werden. Zum Beispiel ergibt `5+7` das Ergebnis `12`, während `[2,3,4]+[3,-1,5]` das Ergebnis `[5,2,9]` ergibt. Normalerweise gelten alle diese Operatoren für reelle Zahlen sowie für komplexe Zahlen.

#### Der Additionsoperator: `<expr>+<expr>`

Beschreibung: Zahlen (ganze Zahlen, reelle Zahlen, komplexe Zahlen) können mit dem +-Operator addiert werden. Listen mit gleicher Struktur können ebenfalls addiert werden; dann wird die Addition komponentenweise durchgeführt.

Code | Ergebnis
--- | ---
`7 + 8` | `15`
`2.3 + 5.9` | `8.2`
`[2,3,4] + [3,4,6]` | `[5,7,10]`
`[2,3,[1,2]] + [3,4,[1,3]]` | `[5,7,[2,5]]`

Siehe auch: String-Operatoren

#### Der Subtraktionsoperator: `<expr>-<expr>`

Beschreibung: Zahlen (ganze Zahlen, reelle Zahlen, komplexe Zahlen) können mit dem `-`-Operator subtrahiert werden. Listen der gleichen Form können ebenfalls subtrahiert werden. Die Subtraktion wird dann komponentenweise durchgeführt. Darüber hinaus kann der `-`-Operator als unäres Minus verwendet werden.

Code | Ergebnis
--- | ---
`7 - 8` | `-1`
`8.3 - 5.9` | `2.4`
`[2,6,4] - [3,4,6]` | `[-1,2,-2]`
`[5,3,[1,2]] - [3,4,[1,3]]` | `[2,-1,[0,-1]]`

Siehe auch: String-Operatoren

#### Der Multiplikationsoperator: `<expr>*<expr>`

Beschreibung: Zahlen (ganze Zahlen, reelle Zahlen, komplexe Zahlen) können mit dem `*`-Operator multipliziert werden. Listen, die numerische Vektoren oder numerische Matrizen darstellen, können ebenfalls multipliziert werden, wenn die Dimensionen eine sinnvolle mathematische Operation zulassen. Siehe die Beispiele für weitere Beschreibungen.

Code | Ergebnis
--- | ---
`7 * 8` | `56` (Multiplikation von Ganzzahlen)
`(1+i) * (2+i)` | `1+3*i` (Multiplikation von komplexen Zahlen)
`2 * [5,3,2]` | `[10,6,4]` (skalare Multiplikation von Zahl und Vektor)
`[5,3,2] * 2` | `[10,6,4]` (skalare Multiplikation von Zahl und Vektor)
`[2,2,3] * [3,4,6]` | `32` (Skalarprodukt zweier Vektoren) (x_1,x_2,…,x_n)*(y_1,y_2, …,y_n)=(x_1*y_1+…+x_n*y_n))
`[[1,2],[3,4]] * [1,2]` | `[5,11]` (Matrix mal Vektor)
`[1,2] * [[1,2],[3,4]]` | `[7,10]` (Vektor mal Matrix)
`[[1,2],[3,4]] * [[1,2],[3,4]]` | `[[7,10],[15,22]]` (Produkt zweier Matrizen)

Siehe auch: Vektoren und Matrizen

#### Der Divisionsoperator: `<expr>/<number>`

Beschreibung: Zahlen (ganze Zahlen, reelle Zahlen, komplexe Zahlen) können mit dem `/`-Operator dividiert werden. Auch ein Vektor kann durch eine Zahl dividiert werden.

Code | Ergebnis
--- | ---
`56 / 8` | `7`
`[6,8,4] / 2` | `[3,4,2]`

#### Der Potenzoperator: `<expr>^<expr>`

Beschreibung: Eine Zahl (ganze Zahl, reelle Zahl, komplexe Zahl) kann mit einer anderen Zahl (ganze Zahl, reelle Zahl, komplexe Zahl) potenziert werden. Beachten Sie, dass nicht nur ganzzahlige Potenzen zulässig sind. In `a^b` kann der Exponent `b` eine beliebige reelle oder komplexe Zahl sein. Formal wird der Ausdruck `exp(b*ln(a))` berechnet. Da `ln(…)` nur bis zu einem Zeitraum von `2*pi` definiert ist, ist der Ausdruck `a^b` im Allgemeinen mehrwertig. Für nicht ganzzahlige Werte von `b` wird nur ein Hauptwert von `a^b` zurückgegeben.

Code | Ergebnis
--- | ---
`5^2` | `25`
`5^(-1)` | `0.2`
`2^(1/2)` | `1.4142…`

#### Der Gradoperator: `<number>°`

Dieser Operator multipliziert jede Zahl mit der Konstante `pi/180`. Dies ermöglicht die Umwandlung von Winkeln von Grad in Radianten.

Code | Ergebnis
--- | ---
`180°` | `3.1415…`
`cos(180°)` | `-1`

#### Der Absolutwert-Operator: `|<number>|`

Beschreibung: Dieser Operator berechnet den Absolutwert eines Objekts. Das Objekt kann eine einfache Zahl, eine komplexe Zahl oder ein Vektor sein.

Es ist nicht erlaubt, den `|...|`-Operator auf verschachtelte Weise zu verwenden, da solche Ausdrücke syntaktisch mehrdeutig sein können.

Code | Ergebnis
--- | ---
`|-5|` | `5`
`|(3,4)|` | `5`
`|1+i|` | `1.4142`…

#### Der Distanzoperator: `|<number>,<number>|`

Beschreibung: Man kann `|...|` mit zwei Argumenten verwenden, in welchem Fall dieser Operator die Entfernung zwischen den beiden Objekten berechnet. Die Objekte können einfache Zahlen, komplexe Zahlen oder Vektoren sein. Sie müssen jedoch vom gleichen Typ sein.

Es ist nicht erlaubt, den `|...,...|`-Operator auf verschachtelte Weise zu verwenden, da solche Ausdrücke syntaktisch mehrdeutig sein können.

Code | Ergebnis
--- | ---
`|-5,8|` | `13`
`|(1,1),(4,5)|` | `5`

### Funktionale Operatoren

Die folgenden Operatoren können auf Zahlen (ganze Zahl, reelle Zahl, komplexe Zahl) angewendet werden. Einige davon können auch auf Vektoren angewendet werden.

### Arithmetische Funktionen

#### Addition: `add(<expr1>,<expr2>)`

#### Subtraktion: `sub(<expr1>,<expr2>)`

#### Multiplikation: `mult(<expr1>,<expr2>)`

#### Division: `div(<expr1>,<expr2>)`

#### Potenzierung: `pow(<expr1>,<expr2>)`

Beschreibung: Diese Operatoren sind binäre Funktionen, die den Operatoren wie `+`, `-`, `*`, `/` und `^` entsprechen.

Code | Ergebnis
--- | ---
`add(5,6)` | `11`
`pow(6,2)` | `36`
`mod(23,4)` | `3`
`add([1,2],[3,4])` | `(4,6)`
`mult(2,[3,4])` | `(6,8)`
`mult([4,5],[3,4])` | `32`

#### Modulo: `mod(<expr1>,<expr2>)`

Beschreibung: Die Funktion `mod` berechnet den Rest von `<expr1>` bei Division durch `<expr2>`.

### Standardfunktionen

#### Quadratwurzel: `sqrt(<expr>)`

#### Exponentialfunktion: `exp(<expr>)`

#### Natürlicher Logarithmus: `log(<expr>)`

Beschreibung: Diese Funktionen bilden Zahlen auf Zahlen ab. Komplexe Zahlen werden vollständig unterstützt.

### Trigonometrische Funktionen

Die Standard-Trigonometrischen Funktionen sind durch die folgenden Operatoren verfügbar:

#### Trigonometrische Sinusfunktion: `sin(<expr1>)`

#### Trigonometrische Kosinusfunktion: `cos(<expr1>)`

#### Trigonometrische Tangensfunktion: `tan(<expr1>)`

#### Inverse trigonometrische Sinusfunktion: `arcsin(<expr1>)`

#### Inverse trigonometrische Kosinusfunktion: `arccos(<expr1>)`

#### Inverse trigonometrische Tangensfunktion: `arctan(<expr1>)`

#### Winkel eines Vektors: `arctan2(<real1,real2>)`

#### Winkel eines Vektors: `arctan2(<vec>)`

Die `arc`-Operatoren sind im Prinzip mehrwertig. Der Operator gibt jedoch nur einen Hauptwert zurück, für den der reelle Wert zwischen `+pi` und `-pi` liegt.

Code | Ergebnis
--- | ---
`sin(pi)` | `0`
`arccos(-1)` | `3.1415`…
`arctan2(1,1)` | `45°`
`arctan2(-1,-1)` | `-135°`

### Numerische Funktionen

#### Absolutwert: `abs(<expr>)`

#### Gerundeter Wert: `round(<expr>)`

#### Größte ganze Zahl kleiner oder gleich: `floor(<expr>)`

#### Kleinste ganze Zahl größer oder gleich: `ceil(<expr>)`

#### Realteil einer komplexen Zahl: `re(<expr>)`

#### Imaginärteil einer komplexen Zahl: `im(<expr>)`

#### Konjugierte einer komplexen Zahl: `conjugate(<expr>)`

Beschreibung: Für komplexe Zahlen werden die Operatoren `round`, `floor` und `ceil` separat auf den Real- und Imaginärteil angewendet.

Die Funktion `abs` berechnet die Normen von Zahlen, komplexen Zahlen, Vektoren usw. Alle anderen Funktionen können auch auf Listen angewendet werden, in welchem Fall sie komponentenweise angewendet werden.

Code | Ergebnis
--- | ---
`round(4.3)` | `4`
`round([3.2,7.8,3.1+i*6.9])` | `[3,8,3+i*7]`
`abs([1,3,1,2,1])` | `4`
`floor(4.8)` | `4`

### Zufallszahl-Operatoren

Die folgenden Operatoren generieren Pseudo-Zufallszahlen.

#### Gleichmäßig verteilte Zufallszahl zwischen 0 und 1: `random()`

#### (0,1)-normalverteilte Zufallszahl: `randomnormal()`

#### Zufalliger boolescher Wert `true` oder `false`: `randombool()`

#### Gleichmäßig verteilte Zufallszahl zwischen 0 und `<number>`: `random(<number>)`

#### Gleichmäßig verteilte Zufallszahl zwischen 0 und `<number>`: `randomint(<number>)`

Beschreibung: Die Zufallsgeneratoren akzeptieren auch negative und komplexe Zahlen als Argumente. Zum Beispiel generiert `random(-5)` eine Zufallszahl zwischen `-5` und `0`; `randomint(6+i*10)` generiert eine zufällige komplexe Zahl, für die der Realteil eine ganze Zahl zwischen 0 und 6 ist und der Imaginärteil eine ganze Zahl zwischen 0 und 10 ist.

#### Zufallsgenerator initialisieren: `seedrandom(<number>)`

Beschreibung: Der Pseudo-Zufallsgenerator wird immer unvorhersehbar neue Zufallszahlen produzieren. Wenn man aus irgendeinem Grund die gleichen Zufallszahlen für verschiedene Läufe eines Skripts generieren möchte, kann man den Operator `seedrandom(<number>)` verwenden. Nachdem diese Funktion mit einer bestimmten ganzen Zahl aufgerufen wird, wird die gleiche Sequenz von Zufallszahlen deterministisch generiert. Jede Seeding-Zahl produziert eine andere Sequenz von Zufallszahlen.

Diese Seite wurde automatisch mit KI (Claude) übersetzt und wartet noch auf Überprüfung. → Alle KI-übersetzten Seiten