*MINVAL/*MAXVAL - Minimal-/Maximalwertes eines Feldes

#### Search Results

Search

# *MINVAL/*MAXVAL - Minimal-/Maximalwertes eines Feldes

| `*MINVAL` |  | `([`(`IR`=result-format/length)`]` operand,...`)`
`*MAXVAL`

`format/length`: Format und Länge können entweder explizit mit der `IR`-Klausel angegeben oder automatisch mit Hilfe den unten aufgeführten Tabellen errechnet werden, siehe Tabelle für die Konvertierung der `resulting-format/length`-Werte.

Die folgenden Themen werden behandelt:

- Funktion

- Einschränkungen

- Syntax-Beschreibung

- Tabelle für die Konvertierung der resulting-format/length-Werte

- Berechnung der result-format-length

## Funktion

Die Natural-Systemfunktion `*MINVAL` bzw. `*MAXVAL` wertet die Minimal-/Maximalwerte aller gegebenen Operanden aus. Das Ergebnis ist immer ein Skalarwert. Wird ein Array als Operand angegeben, dann wird der Minimal- bzw. Maximalwert aller Array-Felder ausgewertet.

Wenn bei Verwendung von alphanumerischen oder binären Daten dieselben Daten als Argument angegeben sind, (z.B. `*MINVAL('AB','AB')`), dann ist das Ergebnis das Argument mit dem kleinsten/größten Längenwert.

## Einschränkungen

Für die Verwendung der Systemfunktion `*MINVAL`/`*MAXVAL` gelten folgende Einschränkungen:

- `*MINVAL`/`*MAXVAL` darf nicht an Stellen verwendet werden, an denen eine Zielvariable erwartet wird.

- `*MINVAL`/`*MAXVAL` darf nicht in einer anderen Systemfunktion verschachtelt werden

## Syntax-Beschreibung

Operanden-Definitionstabelle:

Operand | Mögliche Struktur | Mögliche Formate | Referencing Permitted | Dynamic Definition
--- | --- | --- | --- | ---
operand | C | S | A | G |  | A | U | N | P | I | F | B | D | T |  |  |  |  | yes | no

Syntax-Elementbeschreibung:

Schlüsselwort | Beschreibung
--- | ---
`*MINVAL` | Berechnet den Minimalwert aller gegebenen Operandenwerte.
`*MAXVAL` | Berechnet den Minimalwert aller gegebenen Operandenwerte.
`operand` | Der Operand bzw. die Operanden, deren Minimal-/Maximalwert(e) von der Systemfunktion `*MINVAL` bzw. `*MAXVAL` errechnet werden soll.
`result-format-length` | `IR`-Klausel zur expliziten Angabe der resultierenden Format/Länge-Werte. Siehe unten.

### IR-Klausel

Diese Klausel kann zur expliziten Angabe der `result-format/length`-Werte für die gesamte Systemfunktion `*MINVAL` bzw. `*MAXVAL` verwendet werden.

    IR=result-format/length

`IR=` |  | format-length |
`(` |  | `A` `U` `B` |  | `)` `DYNAMIC`

Eine Aufstellung der gültigen result-format/length-Werte ist im Abschnitt Tabelle für die Konvertierung der resulting-format/length-Werte enthalten.

Syntax-Elementbeschreibung:

Schlüsselwort | Beschreibung
--- | ---
`format-length` | Der Compiler versucht, die resultierenden Format-/Längenwerte der Gesamtfunktion zu bestimmen. Wenn dies nicht ohne Einbußen an Genauigkeit möglich ist, muss der Programmierer die `format-length`-Werte mit Hilfe der `IR`-Operandenerweiterung angeben.
`A`, `U` oder `B` | Format: Alphanumerisch oder binär für dynamische Variable.
`DYNAMIC` | Anstelle von festen Format-/Längenwerten kann auch ein alphanumerisches, Unicode- oder binäres Format mit dynamischer Länge angegeben werden.

Beispiel:

    DEFINE DATA LOCAL
    1 #RESULTI       (I4)
    1 #RESULTA       (A20)
    1 #RESULTADYN    (A) DYNAMIC
    1 #A(I4)         CONST <1234>
    1 #B(A20)        CONST <H'30313233'> /* '0123' stored
    1 #C(I2/1:3)     CONST <2000, 2100, 2200>
    END-DEFINE
    *
    #RESULTA     := *MAXVAL((IR=A20)         #A, #B)     /*no error, I4->A20 is allowed!
    #RESULTADYN  := *MAXVAL((IR=(A)DYNAMIC)  #A, #B)     /*result is (A) dynamic
    /* #RESULTI  := *MAXVAL((IR=I4)          #A, #B)     /*compiler error, because conv. A20->I4 is not allowed!
    #RESULTI     := *MAXVAL((IR=I4)          #A, #C(*))  /*maximum of the array is evaluated
    DISPLAY #RESULTA #RESULTADYN (AL=10) #RESULTI
    END

## Tabelle für die Konvertierung der resulting-format/length-Werte

Es gibt zwei Arten, die resultierenden Format-/Längenwerte für die gesamte Systemfunktion `*MINVAL`/`*MAXVAL` anzugeben.

- Explizite Angabe der resultierenden Format-/Längenwerte

- Implizite Angabe der resultierenden Format-/Längenwerte

### Explizite Angabe der resultierenden Format-/Längenwerte

Die resultierenden Format-/Längenwerte für die gesamte Systemfunktion `*MINVAL` bzw. `*MAXVAL` können mit der `IR`-Klausel angegeben werden. Alle angegebenen Operanden werden in die mit dieser Klausel festgelegten resultierenden Format-/Längenwerte umgewandelt, wenn dies ohne Einbußen bezüglich der Genauigkeit möglich ist. Anschließend erfolgt die Berechnung der Minimal- bzw. Maximalwerte aller umgewandelten Operanden, und es wird ein einziger Skalarwert mit dem errechneten Format-/Längenwert als Ergebnis für die gesamte Systemfunktion festgelegt.

### Implizite Angabe der resultierenden Format-/Längenwerte

Wenn keine `IR`-Klausel in der Systemfunktion `*MINVAL` bzw. `*MAXVAL` verwendet wird, erfolgt die Berechnung der resultierenden Format-/Längenwerte anhand der Formate/Längen aller in der Systemfunktion als Argument angegebenen Operanden. Dabei wird der `format/length`-Wert jedes einzelnen Operanden genommen und mit dem `format/length`-Wert des darauf folgenden Operanden in der Argument-Liste zusammengefasst. Der resultierenden Format-/Längenwert von zwei einzelnen Operanden wird dann gemäß der unten aufgeführten Tabellen errechnet.

Die Tabelle für die Konvertierung der `resulting-format/length`-Werte ist in zwei Untertabellen aufgeteilt. Kombinationen, die nicht in diesen beiden Tabellen aufgeführt sind, sind ungültig und dürfen in der Argument-Liste der Systemfunktion `*MINVAL` bzw. `*MAXVAL` nicht verwendet werden. Das Schlüsselwort `FLF` gibt an, wann zur Vermeidung von Ungenauigkeiten die `IR`-Klausel zur Festlegung des resultierenden Format-/Längenwertes benutzt werden muss.

#### Tabelle 1

Enthält alle nummerischen Kombinationsmöglichkeiten für zwei verschiedene Operanden.

| Zweiter Operand
--- | ---
Format/Länge | I1 | I2 | I4 | Pa.b, Na.b | F4, F8
Erster Operand | I1 | I1 | I2 | I4 | Pmax(3,a).b | F8
I2 | I2 | I2 | I4 | Pmax(5,a).b | F8
I4 | I4 | I4 | I4 | Pmax(10,a).b | F8
Px.y, Nx.y | Pmax(3,x).y | Pmax(5,x).y | Pmax(10,x).y | wenn max(x,a) + max(y,b) <= 29 Pmax(x,a).max(y,b) sonst `FLF` | wenn y=0 und x <=15; F8 sonst `FLF`
F4, F8 | F8 | F8 | F8 | wenn b=0 und a <=15 F8 sonst `FLF` | F8

Legende:

FLF | Format-/Längenangabe mittels `IR`-Klausel zwingend erforderlich.
Ix | Format/Länge ist Integer (Ganzzahl). x gibt die Anzahl der Bytes an, die zum Speichern des Integer-Wertes benutzt werden.
Fx | Format/Länge ist Float (Gleitkomma). x gibt die Anzahl der Bytes an, die zum Speichern des Float-Wertes benutzt werden.
Px.y Pa,b | Format ist Packed (gepackt) mit entsprechender Anzahl an Stellen vor dem Dezimalpunkt (x,a) und der Genauigkeit (y,b).
Nx.y Na,b | Format ist Numeric (nummerisch) mit entsprechender Anzahl an Stellen vor dem Dezimalpunkt (x,a) und der Genauigkeit (y,b).
Pmax(c,d).e | Das resultierende Format ist Packed (gepackt). Die Berechnung der Länge erfolgt anhand der nachfolgenden Informationen. Die Anzahl an Stellen vor dem Dezimalpunkt ist der Maximalwert von c und d. Der Genauigkeitswert ist e.
Pmax(c,d).max(e,f) | Das resultierende Format ist Packed (gepackt). Die Berechnung der Länge erfolgt anhand der nachfolgenden Informationen. Die Anzahl an Stellen vor dem Dezimalpunkt ist der Maximalwert von c und d. Der Genauigkeitswert ist der Maximalwert von e und f.

#### Tabelle 2

Enthält alle Formate und Längen, die für Operanden in den Systemfunktionen `*MINVAL`/`*MAXVAL` verwendet werden können.

| Zweiter Operand
--- | ---
Format-length | D | T | Aa, A dynamic | Ba, B dynamic | Ua, U dynamic
Erster Operand | D | D | T | NA | NA | NA
T | T | T | NA | NA | NA
Ax, A dynamic | NA | NA | A dynamic | A dynamic | U dynamic
Bx, B dynamic | NA | NA | A dynamic | B dynamic | U dynamic
Ux, U dynamic | NA | NA | U dynamic | U dynamic | U dynamic

Legende:

NA | Unzulässige Kombination.
D | Datenformat.
T | Zeitformat.
Bx, Ba | Binärformat mit Länge x, a.
Ax, Aa | Alphanumerisches Format mit Länge x, a.
Ux, Ua | Unicode-Format mit Länge x, a.
B dynamic | Binärformat mit dynamischer Länge.
A dynamic | Alphanumerisches Format mit dynamischer Länge.
U dynamic | Unicode-Format mit dynamischer Länge.

## Berechnung der result-format-length

Anhand der oben aufgeführten Regeln ist der Compiler in der Lage, die Source-Operanden unter Berücksichtigung von Operandenpaaren zu verarbeiten und die Zwischenergebnisse für jedes Paar zu berechnen. Das erste Paar besteht aus dem ersten und dem zweiten Operand, das zweite Paar aus dem Zwischenergebnis und dem dritten Operand usw. Nach Verarbeitung aller Operanden stellt das letzte Ergebnis den Vergleich zwischen Format und Länge dar, die zum Vergleich mit allen Operanden zwecks Berechnung des Minimal- bzw. Maximalwertes verwendet werden. Bei Verwendung dieser Format-/Längenberechnungsmethode können die Operanden in beliebiger Reihenfolge auftreten.

Beispiel:

    DEFINE DATA LOCAL
    1 A (I2)      INIT <34>
    1 B (P4.2)    INIT <1234.56>
    1 C (N4.4)    INIT <12.6789>
    1 D (I1)      INIT <100>
    1 E (I4/1:3)  INIT <32, 6745, 456>
    1 #RES-MIN (P10.7)
    1 #RES-MAX (P10.7)
    END-DEFINE
    *
    MOVE *MINVAL(A, B, C, D, E(*)) TO #RES-MIN
    MOVE *MAXVAL(A, B, C, D, E(*)) TO #RES-MAX
    DISPLAY #RES-MIN #RES-MAX
    END

Ausgabe:

            #RES-MIN                      #RES-MAX
    ---------------------------  ---------------------------

                     12.6789000                 6745.0000000

Die folgende Tabelle zeigt die einzelnen Schritte zur automatischen Format-/Längenberechnung im obigen Beispiel. Sie enthält die Zwischenergebnisse (ir) aller Schritte und den Format-/Längenwert des Vergleichs (cf), der als result-format/length-Wert verwendet wird.

Berechnungs- reihenfolge | Name des ersten Operanden | Format/Länge des ersten Operanden bzw. Zwischenergebnis (ir) | Name des zweiten Operanden | Format/Länge des zweiten Operanden bzw. Zwischenergebnis (ir) | Format/Länge des Zwischenergebnisses(ir)
--- | --- | --- | --- | --- | ---
1. | A | I2 | B | P4.2 | ir1 = P5.2
2. | ir1 | P5.2 | C | N4.4 | ir2 = P5.4
3. | ir2 | P5.4 | D | I1 | ir3 = P5.4
4. | ir3 | P5.4 | E | I4 | cf = P10.4

Zur Laufzeit werden alle Operanden in die cf-Format/Länge umgewandelt. Danach werden alle umgewandelten Werte miteinander verglichen und der entsprechende Minimal- bzw. Maximalwert wird errechnet.

#### Anmerkungen:

1. Wenn nur ein einzelner Operand angegeben wird, hat result-format-length der Format-/Längenwert dieses Operanden.

2. Wenn ein binärer Operand mit einer Länge im Bereich von 1 - 4 als Argument innerhalb der Systemfunktion `*MINVAL`/`*MAXVAL` zusammen mit einem alphanumerischen oder einem Unicode-Operanden angegeben wird, dann wird das Zwischenergebnis (result-format-length) als alphanumerisches bzw. als Unicode-Format mit dynamischer Länge bewertet.

   In diesem Fall wird der Wert des binären Operanden als numerischer Wert betrachtet, der gemäß den Datenübertragungsregeln in das result-format-length umgewandelt wird (der binäre numerische Wert wird in das Format Upacked gewandelt), bevor der Minimal-/Maximalwert berechnet wird.

   Beispiel:

       DEFINE DATA LOCAL
       1 #B4 (B4)  INIT <1>
       1 #A10(A10) INIT <"2">
       END-DEFINE
       WRITE "=" *MAXVAL(#A10, #B4) (AL=60) /* RESULT FORMAT-LENGTH IS (A)DYNAMIC: "2"
       WRITE "=" *MINVAL(#A10, #B4) (AL=60) /* RESULT FORMAT-LENGTH IS (A)DYNAMIC: "1"
       END

   Der Zwischenwert result-format-length (`#A10`, `#B4`) ist A dynamisch.

   Daher wird zunächst `#A10` nach A dynamisch gewandelt, ebensowie `#B4` nach A dynamisch gewandelt wird (unter Berücksichtigung der Datenübertragungsregeln), bevor das Zwischenergebnis der beiden Operanden berechnet wird.

### Reihenfolge der Berechnung von Format und Länge

Die folgende Grafik zeigt die Reihenfolge, in der die Berechnung von Format und Länge erfolgt:

Legende:

ir1, ir2, ir3 | Zwischenergebnis (intermediate result) 1, 2, 3.
cf | Resultierende Vergleich-Format- und Längewerte (comparison).

### On this page

- Funktion
- Einschränkungen
- Syntax-Beschreibung
- Tabelle für die Konvertierung der resulting-format/length-Werte
- Berechnung der result-format-length