BC- (1) página manual

Nome

BC - Uma linguagem de calculadora de precisão arbitrária

Sintaxe

bc [[ -HLWSQV ] [longas opções] [ arquivo… ]

Versão

Esta página do homem documenta o GNU BC versão 1.06.

Descrição

bc é um idioma que suporta números de precisão arbitrários com execução interativa de declarações. Existem algumas semelhanças na sintaxe à linguagem de programação C. Uma biblioteca de matemática padrão está disponível por opção de linha de comando. Se solicitado, a biblioteca de matemática é definida antes de processar qualquer arquivo. bc Inicia processando o código de todos os arquivos listados na linha de comando na ordem listada. Depois que todos os arquivos foram processados, bc lê a partir da entrada padrão. Todo o código é executado como é lido. (Se um arquivo contiver um comando para interromper o processador, bc nunca vai ler a partir da entrada padrão.)

Esta versão de bc contém várias extensões além do tradicional bc implementações e o padrão de rascunho do Posix. As opções de linha de comando podem causar essas extensões para imprimir um aviso ou ser rejeitado. Este documento descreve o idioma aceito por este processador. Extensões serão identificadas como tal.

Opções

-H, -Help

Imprima o uso e saída.

-Eu, -interativo

Força o modo interativo.

-L, -Mathlib

Defina a biblioteca de matemática padrão.

-W, -warn

Dê avisos para extensões ao POSIX bc.

-S, -padrão

Processe exatamente o Posix bc linguagem.

-Q, -quiet

Não imprima o GNU BC normal bem -vindo.

-v, -version

Imprima o número da versão e os direitos autorais e saia.

Números

O elemento mais básico em bc é o número. Números são números de precisão arbitrários. Esta precisão está na parte inteira e na parte fracionária. Todos os números são representados internamente em decimal e toda a computação é feita em decimal. (Esta versão truncena os resultados das operações de dividir e multiplicar.) Existem dois atributos de números, o comprimento e a escala. O comprimento é o número total de dígitos decimais significativos em um número e a escala é o número total de dígitos decimais após o ponto decimal. Por exemplo:

 .000001 tem um comprimento de 6 e escala de 6. 1935.000 tem um comprimento de 7 e uma escala de 3.

Variáveis

Os números são armazenados em dois tipos de variáveis, variáveis ​​simples e matrizes. Ambas as variáveis ​​simples e as variáveis ​​de matriz são nomeadas. Os nomes começam com uma carta seguida de qualquer número de letras, dígitos e sublinhados. Todas as cartas devem ser minúsculas. (Nomes alfa-numéricos completos são uma extensão. Em Posix bc Todos os nomes são uma única letra minúscula.) O tipo de variável é claro pelo contexto, porque todos os nomes de variáveis ​​de matriz serão seguidos por colchetes ([]).

Existem quatro variáveis ​​especiais, escala, ibase, obase, e durar. escala define como algumas operações usam dígitos após o ponto decimal. O valor padrão de escala é 0. ibase e obase Defina a base de conversão para números de entrada e saída. O padrão para entrada e saída é base 10. durar (uma extensão) é uma variável que tem o valor do último número impresso. Estes serão discutidos em mais detalhes, quando apropriado. Todas essas variáveis ​​podem ter valores atribuídos a eles e também usados ​​em expressões.

Comentários

Comentários em bc Comece com os personagens /* e terminar com os personagens */. Os comentários podem começar em qualquer lugar e aparecer como um único espaço na entrada. (Isso faz com que comentários delimitem outros itens de entrada. Por exemplo, um comentário não pode ser encontrado no meio de um nome variável.) Os comentários incluem quaisquer novas linhas (final da linha) entre o início e o final do comentário.

Para apoiar o uso de scripts para bc, Um comentário de linha única foi adicionada como uma extensão. Um comentário de linha única começa em um # personagem e continua para o próximo extremo da linha. O fim do caráter de linha não faz parte do comentário e é processado normalmente.

Expressões

Os números são manipulados por expressões e declarações. Como o idioma foi projetado para ser interativo, declarações e expressões são executadas o mais rápido possível. Não há programa "principal". Em vez disso, o código é executado como é encontrado. (Funções, discutidas em detalhes posteriormente, são definidas quando encontradas.)

Uma expressão simples é apenas uma constante. bc converte constantes em números decimais internos usando a base de entrada atual, especificada pela variável ibase. (Há uma exceção nas funções.) Os valores legais de ibase são 2 a 16. Atribuindo um valor fora desse intervalo a ibase resultará em um valor de 2 ou 16. Os números de entrada podem conter os caracteres 0-9 e A-F. (Nota: eles devem ser capitais. Letras minúsculas são nomes de variáveis.) Números de dígitos de um único sempre têm o valor do dígito, independentemente do valor de ibase. (eu.e. A = 10.) Para números de vários dígitos, bc altera todos os dígitos de entrada maiores ou iguais a ibase ao valor de ibase-1. Isso faz o número Fff sempre seja o maior número de 3 dígitos da base de entrada.

Expressões completas são semelhantes a muitos outros idiomas de alto nível. Como existe apenas um tipo de número, não há regras para misturar tipos. Em vez disso, existem regras na escala de expressões. Cada expressão tem uma escala. Isso é derivado da escala dos números originais, a operação realizada e, em muitos casos, o valor da variável escala. Valores legais da variável escala são 0 ao número máximo representável por um número inteiro C.

Nas descrições seguintes de expressões legais, "expr" refere -se a uma expressão completa e "var" refere -se a uma variável simples ou de matriz. Uma variável simples é apenas uma

nome

e uma variável de matriz é especificada como

nome[[expr]

A menos que mencionado especificamente a escala do resultado seja a escala máxima das expressões envolvidas.

- expr

O resultado é a negação da expressão.

++ var

A variável é incrementada por um e o novo valor é o resultado da expressão.

- var

A variável é diminuída por um e o novo valor é o resultado da expressão.

var ++

O resultado da expressão é o valor de
a variável e então a variável são incrementadas por um.

var -

O resultado da expressão é o valor da variável e, em seguida, a variável é diminuída por um.

EXPR + EXPR

O resultado da expressão é a soma das duas expressões.

expr - expr

O resultado da expressão é a diferença das duas expressões.

expr * expr

O resultado da expressão é o produto das duas expressões.

EXPR / EXPR

O resultado da expressão é o quociente das duas expressões. A escala do resultado é o valor da variável escala.

expr % expr

O resultado da expressão é o "restante" e é calculado da seguinte maneira. Para calcular A%B, primeiro A/B é calculado para escala dígitos. Esse resultado é usado para calcular a- (a/b)*b na escala do máximo de escala+escala (b) e escala (a). Se escala está definido como zero e ambas as expressões são inteiros, essa expressão é a função do restante inteiro.

expr ^ expr

O resultado da expressão é o valor do primeiro elevado para o segundo. A segunda expressão deve ser um número inteiro. (Se a segunda expressão não for um número inteiro, um aviso é gerado e a expressão é truncada para obter um valor inteiro.) A escala do resultado é escala Se o expoente for negativo. Se o expoente for positivo, a escala do resultado é o mínimo da escala da primeira expressão vezes o valor do expoente e o máximo de escala e a escala da primeira expressão. (e.g. escala (a^b) = min (escala (a)*b, max ( escala, escala (a)))).) Deve -se notar que expr^0 sempre retornará o valor de 1.

(expr)

Isso altera a precedência padrão para forçar a avaliação da expressão.

var = expr

A variável recebe o valor da expressão.

var = expr

Isso é equivalente a "var = var expr" com a exceção de que a parte "var" é avaliada apenas uma vez. Isso pode fazer a diferença se "var" for uma matriz.

Expressões relacionais são um tipo especial de expressão que sempre avalia em 0 ou 1, 0 se a relação for falsa e 1 se a relação for verdadeira. Estes podem aparecer em qualquer expressão legal. (Posix BC exige que expressões relacionais sejam usadas apenas em se, enquanto e para declarações e que apenas um teste relacional pode ser feito nelas.) Os operadores relacionais são

EXPR1 < expr2

O resultado é 1 se expr1 for estritamente menor que expr2.

EXPR1 <= expr2

O resultado é 1 se expr1 for menor ou igual a expr2.

EXPR1> EXPR2

O resultado é 1 se o expr1 for estritamente maior que o expr2.

expr1> = expr2

O resultado é 1 se expr1 for maior ou igual a expr2.

expr1 == expr2

O resultado é 1 se expr1 for igual a expr2.

EXPR1 != expr2

O resultado é 1 se expr1 não for igual a expr2.

Operações booleanas também são legais. (Posix bc não tem operações booleanas). O resultado de todas as operações booleanas é 0 e 1 (para falsas e verdadeiras) como em expressões relacionais. Os operadores booleanos são:

!expr

O resultado é 1 se expr for 0.

expr && expr

O resultado é 1 se ambos os expressões forem diferentes de zero.

EXPR || expr

O resultado é 1 se qualquer uma das expressão for diferente de zero.

A expressão precedência é a seguinte: (mais baixa a mais alta)

|| Operador, Operador da Left Associative &&, Associativa esquerda ! operador, não -associativo

Operadores relacionais,

Operador de atribuição associativa esquerda, Right Associative + e - Operadores,

Associativa esquerda *, / e % operadores, operador de associativa esquerda, associativa direita

Operador de Operador, Operador, Operadores não -ativos e - Operadores, não -associativo

Essa precedência foi escolhida para que a Posix compatível bc Os programas serão executados corretamente. Isso fará com que o uso dos operadores relacionais e lógicos tenha algum comportamento incomum quando usado com expressões de atribuição. Considere a expressão:

a = 3 < 5

A maioria dos programadores C assumiria que isso atribuiria o resultado de “3 < 5” (the value 1) to the variable “a”. What this does in bc é atribuir o valor 3 à variável "a" e depois comparar 3 a 5. É melhor usar parênteses ao usar operadores relacionais e lógicos com os operadores de atribuição.

Existem algumas expressões mais especiais que são fornecidas em bc. Eles têm a ver com funções definidas pelo usuário e funções padrão. Todos eles aparecem como “nome(parâmetros) ““. Veja a seção sobre funções para funções definidas pelo usuário. As funções padrão são:

comprimento (expressão)

O valor da função de comprimento é o número de dígitos significativos na expressão.

ler ( )

A função de leitura (uma extensão) lerá um número da entrada padrão, independentemente de onde a função ocorre. Cuidado, isso pode causar problemas com a mistura de dados e programas na entrada padrão. O melhor uso para esta função está em um programa escrito anteriormente que precisa de entrada do usuário, mas nunca permite que o código do programa seja inserido do usuário. O valor da função de leitura é o número lido da entrada padrão usando o valor atual da variável ibase Para a base de conversão.

escala (expressão)

O valor da função de escala é o número de dígitos após o ponto decimal na expressão.

sqrt (expressão)

O valor da função SQRT é a raiz quadrada da expressão. Se a expressão for negativa, um erro de tempo de execução será gerado.

Declarações

Declarações (como na maioria das línguas algébricas) fornecem o sequenciamento da avaliação da expressão. Em bc As declarações são executadas “o mais rápido possível.”A execução acontece quando uma nova linha encontrada e há uma ou mais declarações completas. Devido a essa execução imediata, as linhas de novo é muito importante em bc. De fato, um ponto de vírgula e uma nova linha são usados ​​como separadores de declaração. Uma nova linha de novo posicionada causará um erro de sintaxe. Como as novas linhas são separadores de declaração, é possível esconder uma nova linha usando o personagem de barra de barragem. A sequência "\", onde está a nova linha parece bc como espaço em branco em vez de uma nova linha. Uma lista de declarações é uma série de declarações separadas por semicolons e novas linhas. A seguir é uma lista de bc Declarações e o que eles fazem: (as coisas incluídas entre colchetes ([]) são partes opcionais da declaração.)

expressão

Esta afirmação faz uma de duas coisas. Se a expressão começar com ""..."", é considerada uma declaração de atribuição. Se a expressão não for uma declaração de atribuição, a expressão será avaliada e impressa na saída. Depois que o número é impresso, uma nova linha é impressa. Por exemplo, ""a = 1"" é uma declaração de atribuição e ""(a = 1)"" é uma expressão que possui uma atribuição incorporada. Todos os números impressos são impressos na base especificada pela variável obase. Os valores legais para obase são 2 através de bc_base_max. (Veja os limites da seção.) Para as bases 2 a 16, o método usual de escrever números é usado. Para bases maiores que 16, bc usa um método de dígito de vários caracteres para imprimir os números em que cada dígito de base mais alto é impresso como um número base 10. Os dígitos de vários caracteres são separados por espaços. Cada dígito contém o número de caracteres necessários para representar o valor da base dez de ""obase-1"". Como os números são de precisão arbitrária, alguns números podem não ser imprimíveis em uma única linha de saída. Esses números longos serão divididos entre as linhas usando o ""\"" como o último caractere em uma linha. O número máximo de caracteres impresso por linha é 70. Devido à natureza interativa de bc, Imprimir um número causa o efeito colateral de atribuir o valor impresso à variável especial durar. Isso permite que o usuário recupere o último valor impresso sem precisar retratar a expressão que imprimiu o número. Atribuindo a durar é legal e substituirá o último valor impresso pelo valor atribuído. O valor recém -atribuído permanecerá até que o próximo número seja impresso ou outro valor seja atribuído a durar. (Algumas instalações podem permitir o uso de um único período (.) que não faz parte de um número como uma notação de mão curta para durar.)

corda

A string é impressa na saída. Strings começam com um caractere de cotação dupla e contêm todos os caracteres até o próximo caractere de cotação dupla. Todos os personagens são levados literalmente, incluindo qualquer nova linha. Nenhum caractere de nova linha é impresso após a string.

imprimir lista

A declaração de impressão (uma extensão) fornece outro método de saída. A ""lista"" é uma lista de cordas e expressões separadas por vírgulas. Cada string ou expressão é impressa na ordem da lista. Nenhum términamento newline está impresso. Expressões são avaliadas e seu valor é impresso e atribuído à variável durar. Strings na declaração de impressão são impressas na saída e podem conter caracteres especiais. Personagens especiais começam com o caractere de barragem (\). Os personagens especiais reconhecidos por bc são ""a"" (alerta ou sino), ""b"" (backspace), ""f"" (feed de formulário), ""n"" (newline), ""r"" (retorno do transporte), ""q"" (citação dupla), ""t ”(Tab) e“ \ ”(barragem). Qualquer outro personagem após a barra de barriga será ignorado.

instrutation_list

Esta é a declaração composta. Ele permite que várias declarações sejam agrupadas para execução.

se (expressão) declaração1 [outro declaração2]

A instrução IF avalia a expressão e executa a instrução1 ou a declaração2, dependendo do valor da expressão. Se a expressão for diferente de zero, a declaração1 será executada. Se a declaração2 estiver presente e o valor da expressão é 0, então a declaração2 será executada. (A cláusula else é uma extensão.)

enquanto (expressão) declaração

A declaração no tempo será executada na declaração enquanto a expressão é diferente de zero. Ele avalia a expressão antes de cada execução da declaração. A rescisão do loop é causada por um valor de expressão zero ou pela execução de uma declaração de quebra.

para ([Expression1]