A Instrução de atribuição especifica cálculo aritmético ou movimentação de dados. Pode ser usada para atribuir o valor de uma expressão aritmética a um item de dados, para atribuir o valor de um item a outro ou para atribuir valores de itens de uma estrutura a itens correspondentes (itens de mesmo nome) de outra estrutura.
>>-resultado--=----+-+-expressão-numérica--+-----+-+-+--;------>< | | '-(R--' | | | '-operando--------------------' | '-função-invocação----------------'
>>-+-expressão-numérica--operador--expressão-numérica--+------->< '---+---+---+-operando-------------+----------------' +---+ '-(expressão numérica)-' '-+-'
Atributo | Descrição | ||
---|---|---|---|
resultado | O resultado de uma instrução de atribuição aritmética pode ser um item de
dados, EZETST, EZEMNO ou EZERCODE. Se for item de dados, pode ser
subscrito, qualificado ou ambos e tem que ser numérico, empacotado ou
binário.
Para outras instruções de atribuição, o resultado pode ser um item dos dados, registro, mapa ou certas palavras de função especial. Se for um item de dados, o resultado poderá ser subscrito, qualificado ou ambos.
| ||
operador | Os seguintes operadores aritméticos são suportados:
Todos os operadores, exceto os unários, têm que vir delimitados por um espaço ou linha, a não ser quando precedidos ou seguidos de parênteses.
Não é permitido operadores na atribuição de instruções que envolvam registros, mapas ou dados não-numéricos. | ||
expressão numérica | Quando a expressão é um cálculo aritmético é verdadeiro que:
| ||
operando | No caos de instruções de atribuição aritméticas, o operando pode ser um
item de dados, um literal numérico ou qualquer palavra de função especial
numérica. Se for item de dados, poderá ser subscrito, qualificado ou
ambos e terá que ser numérico, empacotado ou binário.
Qualquer item de dados de registro pode ser especificado como argumento em chamadas de função de cadeia. E os literais numéricos podem ser especificados em chamadas para algumas palavras de função de cadeia. Consulte "Palavras EZE de Função da Cadeia" para determinar se os literais numéricos poderão ser utilizados com uma determinada função da cadeia. | ||
(R | No caso de instruções de atribuição aritméticas, use (R para arredondar
os resultados ao final de todos os cálculos aritméticos. Quando não se
especifica opção de arredondamento, o resultado é truncado.
Embora o comprimento máximo aceito seja 18, o comprimento máximo de um item de dados utilizado como resultado da opção de arredondamento é 17. O motivo é o fato de se acrescentado internamente um dígito à precisão do item de dados original quando a opção de arredondamento é executada. Qualquer violação em itens numéricos e decimais compactados é detectada no momento que precede o processamento. Nenhuma detecção ocorre para itens de campo de mapa binários e numéricos se mais do que 17 dígitos forem usados no cálculo aritmético arredondado. Em vez disso, um estouro ocorre durante a execução. Implícitos numéricos são criados com um comprimento de 17 em vez de 18 quando usados como itens de dados de resultado de uma operação arredondada. Se você definir uma instrução aritmética com mais de uma operação, todas as operações intermediárias são efetuadas sem a opção de arredondamento. Somente o resultado da última operação é arredondado. Isto é feito somando cinco ao dígito na precisão de um acima da precisão do resultado, e depois truncando. |
Devido à truncação dos resultados intermediários, os programas COBOL podem ter resultados diferentes da GUI ou dos programas C++ para as mesmas instruções aritméticas.
Para garantir resultados consistentes em todos os ambientes, use apenas um operador binário por instrução. Operadores múltiplos de adição ou subtração podem ser associados com segurança se o número de casas decimais definido para o item de resultado for maior ou igual ao número de casas decimais de qualquer um dos operandos.
O operador de resto pode produzir resultados inconsistentes se o resultado ou qualquer dos operandos estiver definido com um número de casas decimais superior a zero. Para obter um resto consistente com o número de casas decimais, use o seguinte algoritmo em vez do operador de resto:
quotient = dividend / divisor ; remainder = dividend - (quotient * divisor) ;
As condições de estouro resultantes de cálculos aritméticos podem ser testadas e controladas por meio as palavras de função especial EZEOVER e EZEOVERS.
Clientes que levam programas do CSP/AE para o VisualAge Generator podem especificar /MATH=CSPAE ao gerar os programas para ambientes COBOL do host para ter certeza de que os resultados de expressões aritméticas são os mesmos no COBOL e quando são executados sob o CSP/AE. Se a aritmética COBOL padrão for satisfatória, use a opção padrão /MATH=COBOL para aumentar o desempenho.
A compatibilidade com CSP/AE não é suportada no dispositivo de teste, na GUI e nos programas C++ gerados.
Instruções CSP/AE que seguem as diretrizes de compatibilidade da seção anterior fornecem resultados consistentes em todos os ambientes.
Suportado em todos os ambientes sem considerações de compatibilidade.
Eis alguns exemplos que usam a Instrução de atribuição como expressão aritmética ou instrução MOVE:
O exemplo a seguir mostra uma expressão aritmética que usa parênteses.
PERCENT-CHANGE = (NEW-VALUE - OLD-VALUE) * 100 / OLD-VALUE;
A ordem de processamento do exemplo dado é determinada pelo parênteses e pela precedência dos operadores:
1st intermediate result1 = (NEW-VALUE minus OLD-VALUE) 2nd intermediate result2 = intermediate result1 multiplied by 100 3rd PERCENT-CHANGE = intermediate result2 divided by OLD-VALUE
Quando uma instrução de atribuição envolve movimentação de dados e a expressão fonte consiste em um operando, a instrução de atribuição trabalha exatamente como a instrução MOVE.
O exemplo abaixo mostra como usar a instrução de atribuição para movimentar ou inicializar dados:
OLD-VALUE = NEW-VALUE;
Exemplos de instruções aritméticas válidas:
OP1 = OP2 + OP3 * OP4; /* Precisam de espaço em torno de *, /, +, -, // OP1 = OP2 * (OP3 + OP4); /* Parênteses forçam soma primeiro. OP1 = OP2 - -OP3; /* Podem existir brancos entre sinais unitários OP1 = OP2 + -OP3; /* e o operando. OP1 = OP2 - -(OP + OP); /* Sinal unitário antes de parênteses é válido. OP1 = OP2 + -(-OP3); /* OP3 é um operando, (-OP3) é um /* operando. OP1 = -OP2 + OP3; /* Você pode iniciar com unitário menos. OP1 = OP2 + OP3(R); /* (R) é um subscrito. OP1 = (OP2) (R; /* Você pode arredondar um operando individual. OP1 = OP2 /(OP3 + OP4); /* Nenhum espaço necessário entre / e (.
Os seguintes exemplos de instrução aritmética não são válidos:
OP1 = OPERAND1 - - -OPERAND2; /* Dois sinais consecutivos não permitidos. OP1 = OP2+OP3*OP4; /* Requer espaços em torno de + e *. OP1 = OP2 (- OP3); /* Operador faltando. OP1 = OP2 *(OP3 +(OP4 / OP5); /* Parênteses não correspondentes. OP1 = OP2 + OP3 * OP5 (R); /* Nenhum espaço permitido antes de subscrito, /* nenhum parêntese direito permitido /* após a opção de arredondamento.
Eis alguns exemplos de instruções de atribuição:
MESSAGE_FIELD = 'Enter option'; /* Configurar mensagem. MESSAGE-NUMBER = 007; /* Inicializar número da mensagem. INIT-MAP = CUST-INFO-RECORD; /* Inicializar campos de mapa.
A instrução de atribuição a seguir não é válida:
MESSAGE_FIELD = ('Enter option'); /* Não use ()s com dados de caractere
O exemplo a seguir usa a opção /MATH=CSPAE:
RESULT = OP1 + OP2 + OP3 (R;
Onde:
Nome do Casas Campo Decimais Comprim. Valor RESULT 2 4 OP1 4 5 1.2345 OP2 3 4 5.678 OP3 4 4 .1169
Essa instrução é executada como a seguir:
HOLD = OP1 + OP2 = 1.234 + 5.678 = 6.912 RESULT = HOLD + OP3 = 6.912 + .116 = 7.028 RESULT = 7.028 + 0.005 = 7.033 RESULT = 7.03
Sem arredondar, a instrução é executada como a seguir:
HOLD = OP1 + OP2 = 1.23 + 5.67 = 6.90 RESULT = HOLD + OP3 = 6.90 + .11 = 7.01
Nota: | O truncamento ocorre nos operandos para corresponder às características do campo RESULT. |
O exemplo a seguir usa a opção /MATH=CSPAE.
Sem arredondamento: A = B - C; Em que: A tem 2 casas decimais e comprimento 3 B = 1.111 C = 3.888 A = -2.78
Nota: | Se o número for negativo, o arredondamento é aplicado no valor absoluto. |
Quando você usa a opção de arredondamento, uma condição de estouro de variável pode ocorrer, dependendo do valor e do número definido de caracteres do item de resultado.
O exemplo a seguir usa a opção /MATH=CSPAE:
Sem arredondamento: A = B + C; Em que: A tem 2 casas decimais e comprimento 3 B = 8.888 C = 1.111 A = 9.99 sem estouro Com arredondamento: A = B + C (R; Em que: A tem 2 casas decimais e comprimento 3 B = 8.888 C = 1.111 A = 0.00 com estouro
A possibilidade de estouro de valor máximo aumenta porque o valor do operando é incrementado.
O exemplo a seguir usa a opção /MATH=CSPAE.
Use números inteiros na parte do operando e do resultado da instrução ao dividir para resto. Para obter restos ao tratar com números outros que não inteiros, use o comprimento e o número de casas decimais para o resultado do resto.
A seguinte fórmula é usada ao calcular o resto:
REMAINDER = DIVIDEND - (DIVISOR * QUOTIENT);
Nota: | Na formula anterior, o valor no QUOTIENT possui o mesmo comprimento e número
de casas decimais que o REMAINDER, como ilustrado no seguinte exemplo:
Nome Tipo Comprimento Dec REMAINDER1 # 8 3 REMAINDER2 # 8 0 A. REMAINDER1 = 12345 // 10000 = 5.000 QUOTIENT1 = 12345 / 10000 = 1.234 |
O exemplo A é calculado como a seguir:
REMAINDER1 = 12345 - (10000 * 1.234) = 5.000 B. REMAINDER2 = 12345 // 10000 = 2345 QUOTIENT2 = 12345 / 10000 = 1
O exemplo B é calculado como a seguir:
REMAINDER2 = 12345 - (10000 * 1) = 2345