Verwenden Sie mathematische Operatoren, Bitoperatoren und selbst zugewiesene Operatoren in PAscript.

Mathematische Operatoren

Verwenden Sie mathematische Operatoren für Integer und Fließkommazahlen.

Wenn Fließkommazahlen und Integer in eine Berechnung einbezogen werden, müssen Sie entsprechende Typumwandlungen in der Berechnung angeben. Weitere Informationen finden Sie unter Typumwandlungen.

Tabelle 49. Mathematische Operatoren
Operator Operation Beispiel Kommentar
+ Addition y=x+1 Der Variablen y wird der Wert von x+1 zugewiesen.
- Subtraktion x=y-1 Der Variablen x wird der Wert von y-1 zugewiesen.
/ Division y=x/10 Der Variablen y wird der Wert von "x geteilt durch 10" (x divided by 10) zugewiesen.
* Multiplikation y=x*a Der Variablen y wird der Wert von "x multipliziert mit a" (x times a) zugewiesen.
mod Modulo y=x mod 2 Der Variablen y wird der Rest der Division von "x geteilt durch 2" (x divided by 2) zugewiesen.
++ Inkrementieren um 1 x++ Die Variable x wird um 1 inkrementiert. Dies ist identisch mit der Anweisung x=x+1.
-- Dekrementieren um 1 y=x-- Die Variable x wird der Variablen y zugewiesen und anschließend um 1 dekrementiert. Dies ist identisch mit den Anweisungen y=x und x=x-1.
+= Kurzschreibweise a = a + ... Kurzschreibweise für a = a + ....
-= Kurzschreibweise a = a - ... Kurzschreibweise für a = a - ....
/= Kurzschreibweise a = a / ... Kurzschreibweise für a = a / ....
*= Kurzschreibweise a = a * ... Kurzschreibweise für a = a * ....
&= Kurzschreibweise a = a & ... Kurzschreibweise für a = a & ....
|= Kurzschreibweise a = a | ... Kurzschreibweise für a = a | ....
^= Kurzschreibweise a = a ^ ... Kurzschreibweise für a = a ^ ....

Die folgenden Richtlinien gelten für Inkrementieren und Dekrementieren.

  • Verwenden Sie Inkrementieren und Dekrementieren für Argumente in Funktionsaufrufen, Schleifen, Berechnungen oder if-Bedingungen.
  • Bei Verwendung einer Variablen in Kombination mit Inkrementieren oder Dekrementieren wird die Variable zuerst verwendet. Dann wird die Variable inkrementiert oder dekrementiert. Die inkrementierte oder dekrementierte Variable darf niemals die Variable auf der linken Seite einer Zuweisung sein. Der Compiler wertet beispielsweise Ausdrücke wie y=y++ oder y=x+y-- nicht aus.

Beispiel: Mathematische Operatoren

program

  int32 x=10, y=0
  y=x++ // => y=x, x=x+1
  sys:logInfo( sys:ui, "x=%d, y=%d", x, y ) // => x=11, y=10
  incDemo ( y++ ) // => a=10
  sys:logInfo( sys:ui, "y=%d", y ) // => y=11
  y=10+x++ // => y=10+x, x=x+1
  sys:logInfo ( sys:ui, "x=%d, y=%d", x, y ) // => x=12, y=21

endprogram


function incDemo( int32 a )
  sys:logInfo ( sys:ui, "a=%d", a ) // => a=10
endfunction

Bitoperatoren

Bitoperatoren können nur mit Integer-Datentypen wie int32 verwendet werden.

Tabelle 50. Bitoperatoren
Operator Operation Beispiel Kommentar
& Bitweise UND y=i&3 Der Variablen y werden die niedrigsten beiden Bits der Variablen i zugewiesen.
| Bitweises ODER y=i|j Die Bits der Variablen i oder j werden einzeln verglichen. Das höherwertige Bit wird der Variablen y zugewiesen.
^ Bitweises Exklusiv-ODER y=i^j Bei Variable y werden nur die Bits gesetzt, die exklusiv in einer der beiden Variablen i oder j gesetzt sind.
<< Bits nach links verschieben y=i<<3 Die Bits der Variablen i werden um drei Stellen in Richtung höherer Bits verschoben. Die Bits werden der Variablen y zugewiesen.
>> Bits nach rechts verschieben y=i>>j Die Bits der Variablen i werden um j in Richtung unterer Bits verschoben. Die Bits werden der Variablen y zugewiesen.

Bitweise arbeitende Operatoren können beliebig aneinander gekettet werden.

Alle Integer-Datentypen, die nur für lokale Variablen verwendet werden können, werden unterstützt.

Beispiel: Bitoperatoren

program
        int32y,i=3,j=2,k=1
        y=(j+k) & i // => bit comparison of i with j+k
        sys: logInfo (sys:ui, "y=%d, i=%d, j=%d, k=%d", y,i,j,k) // => y=3, i=3, j=2, k=1
        y=j&i // => bit comparison of i with j
        sys: logInfo (sys:ui, "y=%d, i=%d, j=%d", y,i,j) // => y=2, i=3, j=2
        y=j|k // => higher bit of j or k is written to y
        sys: logInfo (sys:ui, "y=%d, j=%d, k=%d", y,j,k) // => y=3, j=2, k=1
        y=i|j // => higher bit of i or j is written in y
        sys: logInfo (sys:ui, "y=%d, i=%d, j=%d", y,i,j) // => y=3, i=3, j=2
        y=i^j // => exclusive or of i and j
        sys: logInfo (sys:ui, "y=%d, i=%d, j=%d", y,i,j) // => y=1, i=3, j=2
        i=k<<1 // => shift bits of k 1 place to the left
        sys: logInfo (sys:ui, "i=%d, k=%d", i,k) // => i=2, k=1
        y=i<<j // => shift bits of i j places to the left
        sys: logInfo (sys:ui, "y=%d, i=%d, j=%d", y,i,j) // => y=8, i=2, j=2
        opDemo(i>>k) // => a=1
        sys: logInfo (sys:ui, "i=%d, k=%d", i,k) // => y=11
endprogram

function opDemo(int32a)
        sys:logInfo (sys:ui, "a=%d", a) // => a=1
endfunction

Operatoren mit Selbstzuweisung

Bei Selbstzuweisungen befindet sich die Variable, in die das Ergebnis geschrieben wird, auf der Seite des Ausdrucks mit der Berechnung. Zusammen mit Operatoren mit Standardzuweisung ergibt sich folgende Schreibweise:

variable = variable operator expression

Die Operatoren mit Selbstzuweisung erlauben eine Schreibweise, bei der die Variable nur einmal in die Berechnung geschrieben wird:

variable operator = expression

In der folgenden Tabelle werden die zulässigen Operatoren für Selbstzuweisungen und die möglichen Datentypen für die Variablen beschrieben.

Tabelle 51. Operatoren mit Selbstzuweisung
Operator Numerische Datentypen Text und Puffer
+ ✔ ✔
- ✔ —
* ✔ —
/ ✔ —
& ✔ —
| ✔ —
^ ✔ —

Beispiel: Operatoren mit Selbstzuweisung

text _msg(20) = "Hello"
real64 _x, _y = 3.5714
int32 _i = 2 , _j = 8
_msg += " world!" // => msg = "Hello world!"
_x -= _y // => _x = -3.5714
_j| = _i // => _j = 10