Arithmetische Operatoren

Zu den arithmetischen Operatoren gehören *, /, ^, + und -.

Unärer Negationsoperator

Der unäre Negationsoperator (-) wird für die Typen Ganzzahl, Zahl und Vektor definiert. Bei allen anderen Operandentypen wird ein Fehler generiert. Bei numerischen Typen erhält man das Ergebnis, indem der Operand von Null abgezogen wird. Beim Typ Boolesch wird der Operand mit False verglichen. Beim Typ Vektor wird der Operand umgekehrt (auf alle Koordinaten wird unäre Negation angewendet).

Die folgende Tabelle zeigt Beispiele für den unären Negationsoperator.

Operandentyp	Beispiel	Ergebnis
Numerisch	-3.0	-3.0
Vector	-vector(0,0,1)	Vector_(0.0, 0.0, -1.0, WorldFrame())

Additionsoperator

Der Additionsoperator (+) berechnet die Kombination aus zwei Operanden. Der Additionsoperator ist für die folgenden Typenpaare definiert (der Ausgabetyp wird ebenfalls gezeigt):

• Integer + Integer => Integer
• Integer + Number => Number
• Number + Number => Number
• List + List => List
• Punkt + Vektor => Punkt
• Vector + Vector => Vector
• Name + Name => Name
• Name + Zeichenfolge => Zeichenfolge

Die Reihenfolge ist nicht von Bedeutung.

Bei numerischen Argumenten wird eine numerische Addition durchgeführt. Bei Listenargumenten werden die Listen der Reihenfolge nach aneinandergereiht. Bei Namens- und Zeichenfolgenargumenten werden Namenswerte in Zeichenfolgen umgewandelt und die Zeichenfolgen der Reihenfolge nach aneinandergereiht.

Die folgende Tabelle zeigt Beispiele für den Additionsoperator.

Operandentyp	Beispiel	Ergebnis
Namen	:My + :Name	:MyName
Name und Zeichenfolge	:My + "Name"	"MyName"
Gemischt numerisch	12 + 4.5 + 3.1	19.6
Listen	{:A, :B, :C} + {1, 2.0}	{:a, :b, :c, 1, 2.0}
Punkt und Vektor	Point(0, 0, 0) + Vector(0, 0, 1)	Point_(0.0, 0.0, 1.0, WorldFrame())

Subtraktionsoperator

Der Subtraktionsoperator (-) berechnet die Differenz aus zwei Operanden. Der Subtraktionsoperator ist für die folgenden Typenpaare definiert (der Ausgabetyp wird ebenfalls gezeigt):

• Integer - Integer => Integer
• Integer - Number => Number
• Number - Number => Number
• Number - Integer => Number
• Punkt - Punkt => Vektor
• Punkt - Vektor => Punkt
• Vector - Vector => Vector

Da die Reihenfolge von Bedeutung ist, sind keine anderen Kombinationen zulässig, insbesondere Vektor - Punkt.

Bei numerischen Argumenten wird eine numerische Subtraktion durchgeführt. Bei geometrischen Argumenten werden Vektoroperationen durchgeführt.

Die folgende Tabelle zeigt Beispiele für den Subtraktionsoperator.

Ausdruck	Beispiel	Ergebnis
Punkt - Punkt	Point(0, 0, 0) - Point(10, 0, 0)	Vector_(-10.0, 0.0, 0.0, WorldFrame())
Punkt - Vektor	Point(0, 0, 0) - Vector(1, 0, 0)	Point_(-1.0, 0.0, 0.0, WorldFrame())
Vector - Vector		Vector_(1.0, -1.0, 0.0, WorldFrame())

Multiplikationsoperator

Der Multiplikationsoperator (*) berechnet das Produkt aus zwei Operanden. Der Multiplikationsoperator ist für die folgenden Typen definiert (der Ausgabetyp wird ebenfalls gezeigt):

• Frame * Frame => Frame
• Integer * Integer => Integer
• Integer * Number => Number
• Number * Number => Number
• Integer * Vector => Vector
• Number * Vector => Vector
• Vector * Vector => Vector

Bei einigen Operandentypen wirkt sich die Reihenfolge auf das Ergebnis, aber nicht auf den Ergebnistyp aus.

Bei numerischen Argumenten wird eine numerische Multiplikation durchgeführt. Bei Skalar * Vektor wird der Vektor skaliert. Bei Vektor * Vektor wird das Vektorprodukt berechnet. Bei Frame * Frame wird eine Kombination analog zur Matrixmultiplikation durchgeführt.

Die folgende Tabelle zeigt Beispiele für den Multiplikationsoperator.

Operandentyp	Beispiel	Ergebnis
Numerisch und Vektor	3.0 * Vector(1,0,0)	Vector_(3.0, 0.0, 0.0, WorldFrame())
Vector und Vector	Vector(1,0,0) * Vector(0,1,0)	Vector_(0.0, 0.0, 1.0, WorldFrame())

Divisionsoperator

Der Divisionsoperator (/) berechnet den Quotienten aus zwei Operanden. Der Divisionsoperator ist für die folgenden Typen definiert (der Ausgabetyp wird ebenfalls gezeigt):

• Integer / Integer => Number
• Integer / Number => Number
• Number / Number => Number
• Number / Integer => Number
• Vector / Integer => Vector
• Vector / Number => Vector

Da die Reihenfolge von Bedeutung ist, werden die Vektoroperanden nicht in umgekehrter Reihenfolge definiert.

Beachten Sie, dass eine numerische Division immer eine Zahl ergibt, auch wenn die Zahl eine Ganzzahl ist. Bei Vektoroperationen erfolgt eine Skalierung des Vektors.

Die folgende Tabelle zeigt Beispiele für den Divisionsoperator.

Operandentyp	Beispiel	Ergebnis
Zahl und Ganzzahl	42.0 / 6	7.0
Vector und Integer	Vector(1,0,0)/3	vector(0.33333, 0.0, 0.0, WorldFrame())

Potenzierungsoperator

Die Potenzierungsoperator (^) berechnet den ersten Operanden potenziert mit dem zweiten Operanden. Der Potenzierungsoperator ist für die folgenden Typen definiert (der Ausgabetyp wird ebenfalls gezeigt):

• Integer ^ Integer => Number
• Integer ^ Number => Number
• Number ^ Number => Number

Die Reihenfolge kann sich auf das Ergebnis, aber nicht auf den Ergebnistyp auswirken.

Das Ergebnis ist immer vom Typ Zahl.

Die folgende Tabelle zeigt Beispiele für den Potenzierungsoperator.

Operandentyp	Beispiel
Integer und Integer	6^2	36.0
Integer und Number	6^2.0	36.0
Zahl und Zahl	6.0^2.0	36.0