Programando em Natural - Array

O Natural suporta o processamento de matrizes. Arrays são tabelas multidimensionais, ou seja, dois ou mais elementos logicamente relacionados identificados sob um único nome. As matrizes podem consistir em elementos de dados únicos de múltiplas dimensões ou estruturas de dados hierárquicas que contêm estruturas repetitivas ou elementos individuais.

Definindo Matrizes

No Natural, uma matriz pode ser uni, bi ou tridimensional. Pode ser uma variável independente, parte de uma estrutura de dados maior ou parte de uma visão de banco de dados. Importante:
Variáveis ​​dinâmicas não são permitidas em uma definição de array.
Início do conjunto de instruçõesPara definir uma matriz unidimensional Após o formato e o comprimento, especifique uma barra seguida da chamada "notação de índice", ou seja, o número de ocorrências do array. Por exemplo, a seguinte matriz unidimensional tem três ocorrências, cada ocorrência sendo de formato/comprimento A10:

DEFINE DATA LOCAL 
1 #ARRAY (A10/1:3) 
END-DEFINE 
...

Para definir uma matriz bidimensional

Especifique uma notação de índice para ambas as dimensões:

DEFINE DATA LOCAL 
1 #ARRAY (A10/1:3,1:4) 
END-DEFINE 
...

Uma matriz bidimensional pode ser visualizada como uma tabela. A matriz definida no exemplo acima seria uma tabela composta por 3 "linhas" e 4 "colunas":

+---+---+---+---+
|   |   |   |   |
+---+---+---+---+
|   |   |   |   |
+---+---+---+---+
|   |   |   |   |
+---+---+---+---+

Valores iniciais para matrizes Para atribuir valores iniciais a uma ou mais ocorrências de uma matriz, você usa uma INITespecificação, semelhante àquela para variáveis ​​"comuns" , conforme mostrado nos exemplos a seguir. Atribuindo valores iniciais a matrizes unidimensionais Os exemplos a seguir ilustram como os valores iniciais são atribuídos a uma matriz unidimensional. Para atribuir um valor inicial a uma ocorrência, especifique:

1 #ARRAY (A1/1:3) INIT (2) <'A'> 

A é atribuído à segunda ocorrência.
Para atribuir o mesmo valor inicial a todas as ocorrências, especifique:

1 #ARRAY (A1/1:3) INIT ALL <'A'> 

A é atribuído a cada ocorrência. Como alternativa, você pode especificar:

1 #ARRAY (A1/1:3) INIT (*) <'A'> 

Para atribuir o mesmo valor inicial a um intervalo de várias ocorrências, especifique:

1 #ARRAY (A1/1:3) INIT (2:3) <'A'> 

A é atribuído à segunda à terceira ocorrência. Para atribuir um valor inicial diferente a cada ocorrência, especifique:

1 #ARRAY (A1/1:3) INIT <'A','B','C'> 

A é atribuído à primeira ocorrência, Bà segunda e Cà terceira. Para atribuir valores iniciais diferentes a algumas (mas não todas) ocorrências, especifique:

1 #ARRAY (A1/1:3) INIT (1) <'A'> (3) <'C'> 

A é atribuído à primeira ocorrência e C à terceira; nenhum valor é atribuído à segunda ocorrência. Como alternativa, você pode especificar:

1 #ARRAY (A1/1:3) INIT <'A',,'C'> 

Se forem especificados menos valores iniciais do que ocorrências, as últimas ocorrências permanecem vazias:

1 #ARRAY (A1/1:3) INIT <'A','B'> 

A é atribuído à primeira ocorrência e B à segunda; nenhum valor é atribuído à terceira ocorrência.

Atribuindo valores iniciais a matrizes bidimensionais

Para os exemplos mostrados nesta seção, vamos supor um array bidimensional com três ocorrências na primeira dimensão ("linhas") e quatro ocorrências na segunda dimensão ("colunas"):

1 #ARRAY (A1/1:3,1:4) 

Vertical: Primeira Dimensão (1:3), Horizontal: Segunda Dimensão (1:4):

+-------+-------+-------+-------+
| (1,1) | (1,2) | (1,3) | (1,4) |
| (2,1) | (2,2) | (2,3) | (2,4) |
| (3,1) | (3,2) | (3,3) | (3,4) |
+-------+-------+-------+-------+

O primeiro conjunto de exemplos ilustra como o mesmo valor inicial é atribuído a ocorrências de um array bidimensional; o segundo conjunto de exemplos ilustra como diferentes valores iniciais são atribuídos. Nos exemplos, observe em particular o uso das notações *e V. Ambas as notações referem-se a todas as ocorrências da dimensão em questão: *indica que todas as ocorrências daquela dimensão são inicializadas com o mesmo valor, enquanto Vindica que todas as ocorrências daquela dimensão são inicializadas com valores diferentes .

Atribuindo o mesmo valor

Para atribuir um valor inicial a uma ocorrência, especifique:

1 #ARRAY (A1/1:3,1:4) INIT (2,3) <'A'> 

Resultado

+---+---+---+---+
|   |   |   |   |
+---+---+---+---+
|   |   | A |   |
+---+---+---+---+
|   |   |   |   |
+---+---+---+---+

Para atribuir o mesmo valor inicial a uma ocorrência na segunda dimensão - em todas as ocorrências da primeira dimensão - você especifica:

 1 #ARRAY (A1/1:3,1:4) INIT (*,3) <'A'> 

+---+---+---+---+
|   |   | A |   |
+---+---+---+---+
|   |   | A |   |
+---+---+---+---+
|   |   | A |   |
+---+---+---+---+

Para atribuir o mesmo valor inicial a um intervalo de ocorrências na primeira dimensão - em todas as ocorrências da segunda dimensão - você especifica:

 1 #ARRAY (A1/1:3,1:4) INIT (2:3,*) <'A'> 

Resultado

+---+---+---+---+
|   |   |   |   |
+---+---+---+---+
| A | A | A | A |
+---+---+---+---+
| A | A | A | A |
+---+---+---+---+

Para atribuir o mesmo valor inicial a um intervalo de ocorrências em cada dimensão, especifique:

1 #ARRAY (A1/1:3,1:4) INIT (2:3,1:2) <'A'> 

Resultado

+---+---+---+---+
|   |   |   |   |
+---+---+---+---+
| A | A |   |   |
+---+---+---+---+
| A | A |   |   |
+---+---+---+---+

Para atribuir o mesmo valor inicial a todas as ocorrências (em ambas as dimensões), especifique:

Resultado

+---+---+---+---+
| A | A | A | A |
+---+---+---+---+
| A | A | A | A |
+---+---+---+---+
| A | A | A | A |
+---+---+---+---+

Como alternativa, você pode especificar

 1 #ARRAY (A1/1:3,1:4) INIT (V,2) <'A','B','C'> 

Resultado

+---+---+---+---+
|   | A |   |   |
+---+---+---+---+
|   | B |   |   |
+---+---+---+---+
|   | C |   |   |
+---+---+---+---+

Outra situação

1 #ARRAY (A1/1:3,1:4) INIT (V,2:3) <'A','B','C'> 

Resultado

+---+---+---+---+
|   | A | A |   |
+---+---+---+---+
|   | B | B |   |
+---+---+---+---+
|   | C | C |   |
+---+---+---+---+

Outra situação

1 #ARRAY (A1/1:3,1:4) INIT (V,*) <'A','B','C'>

Resultado

+---+---+---+---+
| A | A | A | A |
+---+---+---+---+
| B | B | B | B |
+---+---+---+---+
| C | C | C | C |
+---+---+---+---+

Outra situação

1 #ARRAY (A1/1:3,1:4) INIT (V,*) <'A',,'C'>

Resultado

+---+---+---+---+
| A | A | A | A |
+---+---+---+---+
| B | B | B | B |
+---+---+---+---+
|   |   |   |   |
+---+---+---+---+

Outra situação

1 #ARRAY (A1/1:3,1:4) INIT (V,1) <'A','B','C'> (V,3) <'D','E','F' >

Resultado

+---+---+---+---+
| A |   | D |   |
+---+---+---+---+
| B |   | E |   |
+---+---+---+---+
| C |   | F |   |
+---+---+---+---+

Outra situação

1 #ARRAY (A1/1:3,1:4) INIT (3,V) <'A','B','C','D'>

Resultado

+---+---+---+---+
|   |   |   |   |
+---+---+---+---+
|   |   |   |   |
+---+---+---+---+
| A | B | C | D |
+---+---+---+---+

Outra situação

1 #ARRAY (A1/1:3,1:4) INIT (*,V) <'A','B','C','D'> 

+---+---+---+---+
| A | B | C | D |
+---+---+---+---+
| A | B | C | D |
+---+---+---+---+
| A | B | C | D |
+---+---+---+---+

Outra situação

1 #ARRAY (A1/1:3,1:4) INIT (2,1) <'A'> (*,2) <'B'> (3,3) <'C'> (3,4) <'D'> 

Resultado

+---+---+---+---+
|   | B |   |   |
+---+---+---+---+
| A | B |   |   |
+---+---+---+---+
|   | B | C | D |
+---+---+---+---+

Outra situação

1 #ARRAY (A1/1:3,1:4) INIT (2,1) <'A'> (V,2) <'B','C','D'> (3,3) <' E'> (3,4) <'F'> 

Resultado

+---+---+---+---+
|   | B |   |   |
+---+---+---+---+
| A | C |   |   |
+---+---+---+---+
|   | D | E | F |
+---+---+---+---+

Uma matriz tridimensional

Uma matriz tridimensional pode ser visualizada da seguinte forma:

A matriz ilustrada aqui seria definida da seguinte forma (ao mesmo tempo atribuindo um valor inicial ao campo destacado na Linha 1, Coluna 2, Plano 2):

DEFINE DATA LOCAL  
1 #ARRAY2  
  2 #ROW (1:4) 
    3 #COLUMN (1:3) 
      4 #PLANE (1:3)  
        5 #FIELD2 (P3) INIT (1,2,2) <100> 
END-DEFINE 
...

Se definido como uma área de dados local no editor de área de dados, o mesmo array teria a seguinte aparência:

I T L Name                             F Leng Index/Init/EM/Name/Comment       
- - - -------------------------------- - ---- ---------------------------------
    1 #ARRAY2                                                                  
    2 #ROW                                    (1:4)                            
    3 #COLUMN                                 (1:3)                            
    4 #PLANE                                  (1:3)                            
I   5 #FIELD2                          P    3   

Arrays como parte de uma estrutura de dados maior As múltiplas dimensões de um array permitem definir estruturas de dados análogas às estruturas COBOL ou PL1. Exemplo:

DEFINE DATA LOCAL  
1 #AREA 
  2 #FIELD1 (A10) 
  2 #GROUP1 (1:10)  
    3 #FIELD2 (P2)  
    3 #FIELD3 (N1/1:4)  
END-DEFINE 
...

Neste exemplo, a área de dados #AREAtem um tamanho total de: 10 + (10 * (2 + (1 * 4))) bytes = 70 bytes #FIELD1é alfanumérico e tem 10 bytes de comprimento. #GROUP1é o nome de uma subárea dentro de #AREA, que consiste em 2 campos e possui 10 ocorrências. #FIELD2é numérico compactado, comprimento 2. #FIELD3é o segundo campo #GROUP1com quatro ocorrências e é numérico, comprimento 1. Para fazer referência a uma ocorrência específica de #FIELD3, são necessários dois índices: primeiro, a ocorrência de #GROUP1deve ser especificada e, segundo, a ocorrência específica de #FIELD3também deve ser especificada. Por exemplo, em uma ADDinstrução posterior no mesmo programa, #FIELD3seria referenciado da seguinte forma:

ADD 2 TO #FIELD3 (3,2) 

Matrizes de banco de dados

O Adabas oferece suporte a estruturas de array dentro do banco de dados na forma de campos de valores múltiplos e grupos periódicos . Eles são descritos em Matrizes de banco de dados . O exemplo a seguir mostra uma DEFINE DATAexibição contendo um campo de vários valores:

DEFINE DATA LOCAL  
1 EMPLOYEES-VIEW VIEW OF EMPLOYEES  
  2 NAME 
  2 ADDRESS-LINE (1:10) /* <--- MULTIPLE-VALUE FIELD 
END-DEFINE 
...

A mesma visualização em uma área de dados local teria a seguinte aparência:

I T L Name                             F Leng Index/Init/EM/Name/Comment       
- - - -------------------------------- - ---- ---------------------------------
  V 1 EMPLOYEES-VIEW                          EMPLOYEES                        
    2 NAME                             A   20                                  
  M 2 ADDRESS-LINE                     A   20 (1:10) /* MU-FIELD 

Usando expressões aritméticas

Uma expressão aritmética simples também pode ser usada para expressar um intervalo de ocorrências em uma matriz. Exemplos:

MA (I:I+5) - Os valores do campo MAsão referenciados, começando com value Ie terminando com value I+5.
MA (I+2:J-3) - Os valores do campo MAsão referenciados, começando com value I+2e terminando com value J-3. 

Somente os operadores aritméticos mais (+) e menos (-) podem ser usados ​​em expressões de índice.

Suporte aritmético para matrizes

O suporte aritmético para arrays inclui operações em nível de array, em nível de linha/coluna e em nível de elemento individual. Somente expressões aritméticas simples são permitidas com variáveis ​​de array, com apenas um ou dois operandos e uma terceira variável opcional como campo receptor. Somente os operadores aritméticos mais (+) e menos (-) são permitidos para expressões que definem intervalos de índice.

Exemplos de Aritmética de Matriz

Os exemplos a seguir assumem as seguintes definições de campo:

DEFINE DATA LOCAL 
01 #A (N5/1:10,1:10) 
01 #B (N5/1:10,1:10) 
01 #C (N5) 
END-DEFINE 
...

1 - O operando resultante, array #B, contém a adição, elemento por elemento, do array #Ae o valor original de array #B.

ADD #A(*,*) TO #B(*,*) 

2 - A segunda coluna da matriz #Aé substituída por seu valor original mais 4.

ADD 4 TO #A(*,2)

3 - A segunda linha da matriz #Aé substituída por seu valor original mais 2.

ADD 2 TO #A(2,*)

4 - O valor da segunda linha do array #Aé adicionado à quarta linha do array #B.

ADD #A(2,*) TO #B(4,*)

5 - Esta é uma operação ilegal e resultará em um erro de sintaxe. Linhas só podem ser adicionadas a linhas e colunas a colunas.

ADD #A(2,*) TO #B(*,2) 

6 - Todos os valores na segunda linha da matriz #Asão adicionados ao valor escalar #C.

ADD #A(2,*) TO #C

7 - Os valores da quinta, sexta e sétima coluna da segunda linha da matriz #Asão adicionados ao valor escalar #C.

Categories: Natural