COMPUTE

#### Search Results

Search

# COMPUTE

#### Structured Mode Syntax

| `COMPUTE` `ASSIGN` |  | [`ROUNDED`] {operand1 [:]= } ... |  | arithmetic-expression operand2 `SUBSTRING` (operand2,operand3,operand4) |  |
{operand1 `:=` } ... |  | arithmetic-expression operand2 `SUBSTRING` (operand2,operand3,operand4) |  |  |  |  |  |  |  |  |  |

#### Reporting Mode Syntax

|  | `COMPUTE` `ASSIGN` |  | [`ROUNDED`] |  | {operand1 [:]= } |  | arithmetic-expression operand2 `SUBSTRING` (operand2,operand3,operand4) |

Dieses Dokument behandelt folgende Themen:

- Funktion COMPUTE

- Syntax-Beschreibung COMPUTE

- Ergebnisgenauigkeit einer Division

- Beispiele COMPUTE

Eine Erläuterung der in dem Syntax-Diagramm verwendeten Symbole entnehmen Sie dem Abschnitt Syntax-Symbole.

Verwandte Statements: `ADD` | `COMPRESS` | `DIVIDE` | `EXAMINE` | `MOVE` | `MOVE ALL` | `MULTIPLY` | `RESET` | `SEPARATE` | `SUBTRACT`

Gehört zur Funktionsgruppe: Arithmetische Funktionen und Datenzuweisungen

## Funktion COMPUTE

Das Statement `COMPUTE` dient zur Ausführung einer arithmetischen Operation sowie dazu, einem oder mehreren Feldern einen Wert zuzuweisen.

Ein `COMPUTE`-Statement mit mehreren Zieloperanden (operand1) ist identisch mit den enstprechenden einzelnen `COMPUTE`-Statements, wenn der Quelloperand (operand2) kein arithmetischer Ausdruck ist.

    #TARGET1 := #TARGET2 := #SOURCE

ist identisch mit

    #TARGET1 := #SOURCE
    #TARGET2 := #SOURCE

Beispiel:

    DEFINE DATA LOCAL
    1 #ARRAY(I4/1:3) INIT <3,0,9>
    1 #INDEX(I4)
    1 #RESULT(I4)
    END-DEFINE
    *
    #INDEX := 1
    *
    #INDEX := 		    /* #INDEX is 3
    #RESULT := 		   /* #RESULT is 9
    #ARRAY(#INDEX)
    *
    #INDEX := 2
    *
    #INDEX  := 		   /* #INDEX is 0
    #ARRAY(3) := 	 	/* returns run time error NAT1316
    #ARRAY(#INDEX)
    END

Wenn der Quelloperand ein arithmetischer Ausdruck ist, wird der Ausdruck ausgewertet und das Ergebnis in einer temporären Variablen abgelegt. Danach wird diese temporäre Variable den Zieloperanden zugeordnet.

    #TARGET1 := #TARGET2 := #SOURCE1 + 1
    is identical to
    #TEMP := #SOURCE1 + 1
    #TARGET1 := #TEMP
    #TARGET2 := #TEMP

Beispiel:

    DEFINE DATA LOCAL
    1 #ARRAY(I4/1:3) INIT <2, 0, 9>
    1 #INDEX(I4)
    1 #RESULT(I4)
    END-DEFINE
    *
    #INDEX := 1
    *
    #INDEX := 		/* #INDEX is 3
    #RESULT := 		/* #RESULT is 3
    #ARRAY(#INDEX) + 1
    *
    #INDEX := 2
    *
    #INDEX  :=		/* #INDEX is 0
    #ARRAY(3) := 		/* returns run time error NAT1316
    #ARRAY(#INDEX)
    END

Weitere Informationen siehe Regeln für arithmetische Operationen im Leitfaden zur Progammierung und dort insbesondere die folgenden Abschnitte:

- Arithmetische Operationen mit Arrays

- Datenübertragung (Informationen zur Kompatibilität der Datenübertragung und zu Regeln für die Datenübertragung)

## Syntax-Beschreibung COMPUTE

Operanden-Definitionstabelle:

Operand | Mögliche Struktur | Mögliche Formate | Referenzierung erlaubt | Dynam. Definition
--- | --- | --- | --- | ---
`operand1` |  | S | A |  | M |  | A | U | N | P | I | F | B | D | T | L | C | G | O | ja | ja
`operand2` | C | S | A |  | N | E | A | U | N | P | I | F | B | D | T | L | C | G | O | ja | nein
`operand3` | C | S |  |  |  |  |  |  | N | P | I |  | B* |  |  |  |  |  |  | ja | nein
`operand4` | C | S |  |  |  |  |  |  | N | P | I |  | B* |  |  |  |  |  |  | ja | nein

* Wenn `operand3` oder `operand4` eine binäre Variable ist, kann er nur mit einer Länge kleiner als/gleich 4 verwendet werden.

Syntax-Element-Beschreibung:

Syntax-Element | Beschreibung
--- | ---
`COMPUTE | ASSIGN [:]=` | Verwendung der Schlüsselwörter: Sie können das Statement in Kurzform angeben und das Statement-Schlüsselwort `COMPUTE` (bzw. `ASSIGN`) weglassen. Wenn Sie im Structured Mode das Statement-Schlüsselwort weglassen, müssen Sie vor das Gleichheitszeichen (=) einen Doppelpunkt (:) schreiben. Verwenden Sie die `ROUNDED`-Option, müssen Sie den Statement-Namen angeben.
`ROUNDED` | ROUNDED-Option: Wenn Sie das Schlüsselwort `ROUNDED` angeben, wird der Wert auf- bzw. abgerundet, bevor er operand1 zugewiesen wird. Die für das Runden gültigen Regeln finden Sie im Abschnitt Regeln für arithmetische Operationen, Abschneiden und Runden von Feldwerten im Leitfaden zur Programmierung.
`operand1` | Ergebnisfeld: operand1 nimmt das Ergebnis der arithmetischen Operation bzw. Zuweisung auf. Zur Genauigkeit des Ergebnisses siehe Abschnitt Genauigkeit von Ergebnissen bei arithmetischen Operationen im Leitfaden zur Programmierung. Wenn operand1 ein Datenbankfeld ist, ändert sich der Wert des Feldes auf der Datenbank dadurch nicht. Falls operand1 eine dynamische Variable ist, wird er bis zur Länge von operand2 oder bis zur Länge des Ergebnisses der arithmetische Operation einschließlich der nachfolgenden Leerzeichen aufgefüllt, und die Länge von operand1 wird dann entsprechend angepasst. Die aktuelle Länge einer dynamischen Variablen kann durch die Systemvariable `*LENGTH` bestimmt werden. Allgemeine Informationen zu dynamischen Variablen entnehmen Sie dem Abschnitt Dynamische und große Variablen benutzen.
`arithmetic-expression` |
Arithmetischer Ausdruck: Ein arithmetischer Ausdruck (arithmetic-expression) besteht aus einer oder mehreren Konstanten, Datenbankfeldern bzw. Benutzervariablen. In Natural verfügbare Mathematische Systemfunktionen (siehe Systemfunktionen-Dokumentation) können ebenfalls als arithmetische Operanden verwendet werden. Die in einem arithmetischen Ausdruck verwendeten Operanden müssen eines der folgenden Formate haben: N, P, I, F, D oder T. Zum Format der Operanden siehe auch Formatwahl im Hinblick auf die Verarbeitungszeit im Leitfaden zur Programmierung. Die folgenden verbindenden Operatoren können verwendet werden:
Operator | Symbol
--- | ---
Klammern | ( )
Potenzierung | **
Multiplikation | *
Division | /
Addition | +
Subtraktion | -
Jedem Operatorzeichen sollte jeweils mindestens ein Leerzeichen voran- und nachgestellt werden, damit es nicht zu Konflikten mit Variablennamen, die eines dieser Zeichen enthalten, kommen kann. Bei der Verarbeitung arithmetischer Operationen gilt folgende Reihenfolge: Klammerrechnung Potenzrechnung Multiplikation/Division (von links nach rechts, wie erkannt) Addition/Subtraktion (von links nach rechts, wie erkannt)
`operand2` | Quellfeld: operand2 ist das Quellfeld. Wenn operand1 das Format C hat, kann operand2 auch als eine Attribut-Konstante angegeben werden (siehe Benutzerkonstanten im Leitfaden zur Programmierung).
`SUBSTRING (operand2,operand3,operand4)` | SUBSTRING-Option: Ohne `SUBSTRING`-Option wird der ganze Inhalt des `operand2` übertragen. Wenn das Format von `operand1` und `operand2` alphanumerisch, Unicode oder binär ist, ermöglicht es Ihnen die `SUBSTRING`-Option, nur einen bestimmten Teil von `operand2` nach `operand1` zu übertragen. In der `SUBSTRING`-Klausel geben Sie nach dem Feldnamen (operand2) zunächst die erste Stelle (operand3) und dann die Länge (operand4) des Feldteils an, der übertragen werden soll. Beispiel: Um die dritte bis sechste Stelle des Feldes `#B` dem Feld `#A` zu übertragen, geben Sie an:
    #A := SUBSTRING(#B,3,4)
Wenn Sie operand3 weglassen, wird ab Anfang des Feldes übertragen. Wenn Sie operand4 weglassen, wird ab der angegebenen Stelle (operand3) bis zum Ende des Feldes übertragen. Anmerkung `MOVE` mit `SUBSTRING`-Option ist eine Byte-für-Byte-Übertragung (d.h. die unter Arithmetische Operationen im Leitfaden zur Programmierung beschriebenen Regeln gelten hierbei nicht). Siehe auch `MOVE SUBSTRING`.

## Ergebnisgenauigkeit einer Division

Die Genauigkeit (Anzahl der Dezimalstellen) des Ergebnisses einer Division in einem `COMPUTE`-Statement bestimmt sich entweder aus der Genauigkeit des ersten Operanden (Dividenden) oder der des ersten Ergebnisfeldes, je nachdem welche größer ist.

Bei einer Division von Ganzzahlen gilt dagegen Folgendes: Die Ergebnisgenauigkeit einer Division von zwei Ganzzahl-Konstanten bestimmt sich aus der Genauigkeit des ersten Ergebnisfeldes. Ist jedoch eine der beiden Ganzzahlen eine Variable, dann ist auch das Ergebnis eine Ganzzahl (d.h. ohne Dezimalstellen, ganz gleich welche Genauigkeit das Ergebnisfeld hat).

## Beispiele COMPUTE

- Beispiel 1 — ASSIGN-Statement

- Beispiel 2 — COMPUTE-Statement

### Beispiel 1 — ASSIGN-Statement

    ** Example 'ASGEX1S': ASSIGN (structured mode)
    ************************************************************************
    DEFINE DATA LOCAL
    1 #A (N3)
    1 #B (A6)
    1 #C (N0.3)
    1 #D (N0.5)
    1 #E (N1.3)
    1 #F (N5)
    1 #G (A25)
    1 #H (A3/1:3)
    END-DEFINE
    *
    ASSIGN #A = 5                           WRITE NOTITLE '=' #A
    ASSIGN #B = 'ABC'                       WRITE '=' #B
    ASSIGN #C = .45                         WRITE '=' #C
    ASSIGN #D = #E = -0.12345               WRITE '=' #D / '=' #E
    ASSIGN ROUNDED #F = 199.999             WRITE '=' #F
    #G     := 'HELLO'                       WRITE '=' #G
    #H (1) := 'UVW'
    #H (3) := 'XYZ'                         WRITE '=' #H (1:3)
    *
    END

Ausgabe des Programms `ASGEX1S`:

    #A:    5
    #B: ABC
    #C:  .450
    #D: -.12345
    #E: -0.123
    #F:    200
    #G: HELLO
    #H: UVW     XYZ

Äquivalentes Reporting-Mode-Beispiel: `ASGEX1R`.

### Beispiel 2 — COMPUTE-Statement

    ** Example 'CPTEX1': COMPUTE
    ************************************************************************
    DEFINE DATA LOCAL
    1 EMPLOY-VIEW VIEW OF EMPLOYEES
      2 PERSONNEL-ID
      2 SALARY    (1:2)
    *
    1 #A          (P4)
    1 #B          (N3.4)
    1 #C          (N3.4)
    1 #CUM-SALARY (P10)
    1 #I          (P2)
    END-DEFINE
    *
    COMPUTE #A = 3 * 2 + 4 / 2 - 1
    WRITE NOTITLE 'COMPUTE #A = 3 * 2 + 4 / 2 - 1' 10X '=' #A
    *
    COMPUTE ROUNDED #B = 3 -4 / 2 * .89
    WRITE 'COMPUTE ROUNDED #B = 3 -4 / 2 * .89' 5X '=' #B
    *
    COMPUTE #C = SQRT (#B)
    WRITE 'COMPUTE #C = SQRT (#B)' 18X '=' #C
    *
    LIMIT 1
    READ EMPLOY-VIEW BY PERSONNEL-ID STARTING FROM '20017000'
      WRITE / 'CURRENT SALARY: '  4X SALARY (1)
            / 'PREVIOUS SALARY:'  4X SALARY (2)
      FOR #I = 1 TO 2
        COMPUTE #CUM-SALARY = #CUM-SALARY + SALARY (#I)
      END-FOR
      WRITE 'CUMULATIVE SALARY:' #CUM-SALARY
    END-READ
    *
    END

Ausgabe des Programms `CPTEX1`:

    COMPUTE #A = 3 * 2 + 4 / 2 - 1          #A:     7
    COMPUTE ROUNDED #B = 3 -4 / 2 * .89     #B:    1.2200
    COMPUTE #C = SQRT (#B)                  #C:    1.1045

    CURRENT SALARY:          34000
    PREVIOUS SALARY:         32300
    CUMULATIVE SALARY:       66300

### On this page

- Funktion COMPUTE
- Syntax-Beschreibung COMPUTE
- Ergebnisgenauigkeit einer Division
- Beispiele COMPUTE