Comando Linux bc

Em sistemas operacionais do tipo Unix, bc é uma linguagem para executar cálculos matemáticos de precisão arbitrária e um intérprete interativo para essa linguagem.

Descrição

bc é uma linguagem que suporta números de precisão arbitrária, o que significa que ele fornece resultados precisos, independentemente do tamanho (ou muito pequeno) dos números.

Possui um modo interativo, aceitando informações do terminal e fornecendo cálculos mediante solicitação. Como uma linguagem, sua sintaxe é semelhante à linguagem de programação C. Uma biblioteca matemática padrão está disponível usando uma opção de linha de comando . Se solicitado, a biblioteca de matemática é definida antes de processar qualquer arquivo.

bc começa processando o código de todos os arquivos listados na linha de comandos na ordem listada. Depois que todos os arquivos foram processados, o bc lê da entrada padrão . Todo o código é executado conforme é lido.

As versões mais recentes do bc contêm várias extensões além das implementações tradicionais do bc e do rascunho do padrão POSIX . As opções de linha de comando podem fazer com que essas extensões imprimam um aviso ou sejam rejeitadas. Este documento descreve a versão mais recente do idioma bc ; onde uma função específica é uma extensão do padrão, ela é observada abaixo.

Sintaxe

  bc [-hlwsqv] [ opções longas ] [ arquivo ...]

Opções

Números

O elemento mais básico em bc é o número. Os números são números de precisão arbitrária. Essa precisão está na parte inteira e na parte fracionária. Todos os números são representados internamente em decimal e todo o cálculo é feito em decimal. Algumas versões de bc truncam resultados de 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 comprimento 6 e escala 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 . Variáveis ​​simples e variáveis ​​de matriz são nomeadas. Os nomes começam com uma letra seguida por qualquer número de letras, dígitos e sublinhados. Todas as letras devem estar em minúsculas . Nomes alfanuméricos completos são uma extensão. No 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: scale , ibase , obase e last .

scale define como algumas operações usam dígitos após o ponto decimal. O valor padrão da escala é 0.

ibase e obase definem a base de conversão para números de entrada e saída. O padrão para entrada e saída é a base 10.

last (uma extensão) é uma variável que possui o valor do último número impresso.

Todas as variáveis ​​podem ter valores atribuídos a elas e podem ser usadas em expressões .

Comentários

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

Para dar suporte ao uso de scripts para bc , um único comentário de linha foi adicionado como uma extensão. Um comentário de linha única começa com um caractere ” # ” e continua até o próximo final de linha. O caractere de fim de linha não faz parte do comentário e é processado normalmente.

Expressões

Os números são manipulados por expressões e instruções. Como a linguagem foi projetada para ser interativa, instruções e expressões são executadas o mais rápido possível. Não existe um programa “principal”; em vez disso, o código é executado conforme é encontrado. As 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 do ibase são de 2 a 16 . A atribuição de um valor fora desse intervalo ao ibase resultará em um valor de 2 ou 16. Os números de entrada podem conter os caracteres de 0 a 9 e AF . Nota: Eles devem ser letras maiúsculas. Letras minúsculas são reservadas para nomes de variáveis. Os números de um dígito sempre têm o valor do dígito, independentemente do valor do ibase . Para números de vários dígitos, bc altera todos os dígitos de entrada maiores ou iguais a ibase para o valor de ibase-1 . Isso faz com que o número FFF seja sempre o maior número de 3 dígitos da base de entrada.

Expressões completas são semelhantes a outras linguagens de alto nível. Como existe apenas um tipo de número, não há regras para misturar tipos de variáveis. Em vez disso, existem regras na escala de expressões. Toda expressão possui uma escala derivada da escala dos números originais, da operação executada e, em muitos casos, do valor da variável. Os valores legais da escala variável são de 0 ao número máximo representável por um número C.

Nas descrições a seguir 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 um nome e uma variável de matriz é especificada como nome [ expr ].

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

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

++ var – A variável é incrementada em um e o novo valor é o resultado da expressão.

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

var ++ – O resultado da expressão é o valor da variável e, em seguida, a variável é incrementada em um.

var – – O resultado da expressão é o valor da variável e, em seguida, a variável é decrementada 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 escala variável.

expr % expr – O resultado da expressão é o “restante” e é calculado da seguinte maneira. Para calcular a % b , primeiro a / b é calculado para escalar dígitos. Esse resultado é usado para calcular a – ( a / b ) * b na escala do máximo de escala + escala ( b ) e escala ( a ) . Se a escala estiver definida como zero e ambas as expressões forem números inteiros, essa expressão será a função restante inteiro.

expr ^ expr – O resultado da expressão é o valor do primeiro elevado à potência do 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 será gerado e a expressão será 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 será o mínimo da escala da primeira expressão vezes o valor do expoente e o máximo da escala e a escala da primeira expressão. (por exemplo, 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 <op> = expr – Esta expressão é equivalente a ” var = var <op> 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 como 0 ou 1: 0 se a relação for falsa e 1 se a relação for verdadeira. Eles podem aparecer em qualquer expressão legal. O POSIX bc requer que expressões relacionais sejam usadas apenas em instruções if , while e for e que apenas um teste relacional possa ser feito nelas. Os operadores relacionais são:

Operações booleanas também são legais. (O POSIX bc NÃO possui operações booleanas). O resultado de todas as operações booleanas são 0 e 1 (para falso e verdadeiro), como nas expressões relacionais. Os operadores booleanos são:

A precedência da expressão é a seguinte: (do menor para o maior)

• || operador, associativo esquerdo
• operador && , associativo à esquerda
• ! operador não-associativo
• Operadores relacionais, associativos à esquerda
• Operador de atribuição, associativo à direita
• operadores + e – , associativo à esquerda
• * , / e % operadores, associativos à esquerda
• ^ operador, associativo certo
• unário – operador, não associativo
• ++ e – operadores, não associativos

Essa precedência foi escolhida para que os programas bc compatíveis com POSIX sejam 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 de C assumiria que isso atribuiria o resultado de ” 3 <5 ” (o valor 1) à variável ” a “. O que isso faz em bc é atribuir o valor 3 à variável ” a ” e comparar 3 a 5 . É melhor usar parênteses ao usar operadores relacionais e lógicos com os operadores de atribuição.

Existem mais algumas expressões especiais fornecidas em bc . Isso tem a ver com funções definidas pelo usuário e funções padrão. Todos eles aparecem como ” nome (parâmetros) “. Consulte 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 length é o número de dígitos significativos na expressão.

ler ( )

A função de leitura (um ramal) lerá um número da entrada padrão, independentemente de onde a função ocorra. Cuidado, isso pode causar problemas com a mistura de dados e programa 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 pelo 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.

Afirmações

As declarações (como na maioria das linguagens algébricas) fornecem o seqüenciamento da avaliação da expressão. Em bc , as instruções são executadas “o mais rápido possível”. A execução acontece quando uma nova linha é encontrada e há uma ou mais instruções completas. Devido a essa execução imediata, as novas linhas são importantes em bc . De fato, um ponto-e-vírgula e uma nova linha são usados ​​como separadores de instrução. Uma nova linha incorretamente colocada causará um erro de sintaxe. Como as novas linhas são separadores de instruções, é possível ocultar uma nova linha usando o caractere de barra invertida. A sequência ” \ <nl> “, onde <nl> é a nova linha, aparece bc como espaço em branco em vez de uma nova linha. Uma lista de instruções é uma série de instruções separadas por ponto e vírgula e novas linhas. A seguir, é apresentada uma lista de instruções bc e o que elas fazem: Itens entre colchetes ( [] ) são partes opcionais da declaração.

  expressão1 ;  while ( expressão2 ) { instrução ;  expressão3 ;  }

Pseudo Declarações

Essas declarações não são declarações no sentido tradicional. Eles não são instruções executadas. Sua função é executada no tempo de “compilação”.

Funções

As funções fornecem um método para definir um cálculo que pode ser executado posteriormente. As funções em bc sempre calculam um valor e o devolvem ao chamador. As definições de função são “dinâmicas” no sentido de que uma função é indefinida até que uma definição seja encontrada na entrada. Essa definição é usada até que outra função de definição para o mesmo nome seja encontrada. A nova definição substitui a definição mais antiga. Uma função é definida da seguinte maneira:

  defina o nome ( parâmetros ) { newline auto_list statement_list }

Uma chamada de função é apenas uma expressão do formulário “nome (parâmetros)”.

Parâmetros são números ou matrizes (um ramal). Na definição da função, zero ou mais parâmetros são definidos listando seus nomes separados por vírgulas. Todos os parâmetros são chamados por parâmetros de valor. As matrizes são especificadas na definição de parâmetro pela notação ” nome [] “. Na chamada de função, parâmetros reais são expressões completas para parâmetros numéricos. A mesma notação é usada para passar matrizes e para definir parâmetros de matriz. A matriz nomeada é passada por valor para a função. Como as definições de função são dinâmicas, os números e tipos de parâmetros são verificados quando uma função é chamada. Qualquer incompatibilidade no número ou tipo de parâmetros causará um erro de tempo de execução. Também ocorrerá um erro de tempo de execução para a chamada para uma função indefinida.

A auto_list é uma lista opcional de variáveis ​​que são para uso “local”. A sintaxe da lista automática (se presente) é ” nome automático, …; “. O ponto e vírgula é opcional. Cada nome é o nome de uma variável automática. As matrizes podem ser especificadas usando a mesma notação usada nos parâmetros. Essas variáveis ​​têm seus valores pressionados em uma pilha no início da função. As variáveis ​​são inicializadas em zero e usadas durante a execução da função. Na saída da função, essas variáveis ​​são exibidas para que o valor original (no momento da chamada da função) dessas variáveis ​​seja restaurado. Os parâmetros são realmente variáveis ​​automáticas que são inicializadas com um valor fornecido na chamada de função. As variáveis ​​automáticas são diferentes das variáveis ​​locais tradicionais porque se a função A chama a função B , B pode acessar as variáveis ​​automáticas da função A usando apenas o mesmo nome, a menos que a função B as chame de variáveis ​​automáticas. Como essas variáveis ​​e parâmetros automáticos são inseridos em uma pilha, o bc suporta funções recursivas .

O corpo da função é uma lista de instruções bc . Novamente, as instruções são separadas por ponto e vírgula ou novas linhas. As instruções de retorno causam o encerramento de uma função e o retorno de um valor. Existem duas versões da declaração de retorno. O primeiro formulário, ” return “, retorna o valor 0 para a expressão de chamada. A segunda forma, ” return (expression) “, calcula o valor da expressão e retorna esse valor para a expressão de chamada. Há um ” retorno (0) ” implícito no final de cada função, que permite que uma função termine e retorne 0 sem uma declaração de retorno explícita.

As funções também alteram o uso da variável ibase . Todas as constantes no corpo da função serão convertidas usando o valor de ibase no momento da chamada da função. As alterações do ibase serão ignoradas durante a execução da função, exceto a função padrão lida, que sempre usará o valor atual do ibase para conversão de números.

Várias extensões foram adicionadas às funções. Primeiro, o formato da definição foi um pouco relaxado. O padrão exige que a chave de abertura esteja na mesma linha que a palavra-chave define e todas as outras partes devem estar nas linhas a seguir. As versões mais recentes do bc permitirão qualquer número de novas linhas antes e depois da chave de abertura da função. Por exemplo, as seguintes definições são legais.

  defina d ( n ) {return (2 * n );  } defina d ( n ) {return (2 * n );  }

As funções podem ser definidas como nulas . Uma função nula não retorna valor e, portanto, não pode ser usada em nenhum lugar que precise de um valor. Uma função nula não produz saída quando chamada sozinha em uma linha de entrada. A palavra-chave nula é colocada entre a palavra-chave define e o nome da função. Por exemplo, considere a seguinte sessão.

  defina py (y) {print "--->", y, "<---", "0;}
 definir px vazio (x) {print "--->", x, "<---", "0;}
 py (1)
 ---> 1 <---
 0 0
 px (1)
 ---> 1 <---

Como py não é uma função nula, a chamada de py (1) imprime a saída desejada e, em seguida, imprime uma segunda linha que é o valor da função. Como o valor de uma função que não recebe uma declaração de retorno explícita é zero, o zero é impresso. Para px (1) , nenhum zero é impresso porque a função é uma função nula.

Além disso, chamada por variável para matrizes foi adicionada. Para declarar uma chamada por matriz variável, a declaração do parâmetro da matriz na definição da função se parece com ” * name [] “. A chamada para a função permanece a mesma que a chamada por matrizes de valor.

Biblioteca de Matemática

Se bc for chamado com a opção -l , uma biblioteca matemática será pré-carregada e a escala padrão será definida como 20. As funções matemáticas calcularão seus resultados para a escala definida no momento da chamada. A biblioteca matemática define as seguintes funções:

• s ( x ) – O seno de x , em radianos.
• c ( x ) – O cosseno de x , em radianos.
• a ( x ) – O arco tangente de x , em radianos.
• l ( x ) – O logaritmo natural de x .
• e ( x ) – A função exponencial de aumentar e para o valor x .
• j ( n , x ) – A função Bessel da ordem inteira n de x .

Exemplos

Em sh , o código a seguir atribuirá o valor de pi à variável de shell pi . Aqui, a refere-se à função arctangent, que faz parte da biblioteca matemática carregada com a opção -l :

  pi = $ (eco "escala = 10; 4 * a (1)" | bc -l)

A seguir está a definição da função exponencial usada na biblioteca de matemática. Esta função está escrita em POSIX bc .

  scale = 20
 / * Usa o fato de que e ^ x = (e ^ (x / 2)) ^ 2
    Quando x é pequeno o suficiente, usamos a série:
      e ^ x = 1 + x + x ^ 2/2!  + x ^ 3/3!  + ...
 * /
 defina e (x) {
   auto a, d, e, f, i, m, v, z
   / * Verifique o sinal de x.  * /
   se (x <0) {
     m = 1
     x = -x
   }
   / * Pré-condição x.  * /
   z = escala;
   escala = 4 + z + 0,44 * x;
   while (x> 1) {
     f + = 1;
     x / = 2;
   }
   / * Inicialize as variáveis.  * /
   v = 1 + x
   a = x
   d = 1
   para (i = 2; 1; i ++) {
     e = (a * = x) / (d * = i)
     if (e == 0) {
       se (f> 0) enquanto (f--) v = v * v;
       scale = z
       se (m) retornar (1 / v);
       retorno (v / 1);
     }
     v + = e
   }
 }

A seguir, é apresentado um código que usa os recursos estendidos do bc para implementar um programa simples para calcular saldos de talões de cheques. É melhor manter esse programa em um arquivo para que ele possa ser usado várias vezes sem precisar digitá-lo novamente a cada uso.

  scale = 2
 imprima "\ nVerifique o programa do livro! \ n"
 print "Lembre-se, depósitos são transações negativas. \ n"
 imprima "Sair por uma transação 0. \ n \ n"
 print "Saldo inicial?";  bal = read ()
 bal / = 1
 imprimir "\ n"
 enquanto (1) {
   "saldo atual =";  bal
   "transação?";  trans = read ()
   se (trans == 0) quebrar;
   bal - = trans
   bal / = 1
 }
 Sair

A seguir, é apresentada a definição da função fatorial recursiva.

  defina f (x) {if (x <= 1) return (1);  return (f (x-1) * x);  }

Comandos relacionados

dc – Um pacote aritmético de precisão arbitrário.
awk – Intérprete para a linguagem de programação de processamento de texto AWK.