Comando Linux dc

Em sistemas operacionais do tipo Unix, o comando dc é uma calculadora aritmética de precisão arbitrária.

Descrição

dc é uma calculadora de mesa que suporta notação aritmética arbitrária e de precisão ilimitada e polimento reverso (postfix). Também permite definir e chamar macros . Normalmente, dc lê da entrada padrão ; se algum argumento de comando é fornecido, eles são nomes de arquivos e o dc lê e executa o conteúdo dos arquivos antes de ler da entrada padrão. Toda saída normal é para saída padrão; toda a saída de erro é para erro padrão.

Uma calculadora de polimento reverso armazena números em uma pilha . Digitar um número o empurra para a pilha. As operações aritméticas retiram os argumentos da pilha e enviam os resultados.

Para inserir um número em dc , digite os dígitos (usando as letras maiúsculas A a F como “dígitos” ao trabalhar com bases de entrada maiores que dez), com um ponto decimal opcional. Notação exponencial não é suportada. Para inserir um número negativo, comece o número com ” _ ” (um sublinhado). ” – ” (traço ou hífen) não pode ser usado para isso, pois é um operador binário para subtração. Para inserir dois números em sucessão, separe-os com espaços ou novas linhas. Estes não têm significado como comandos.

Sintaxe

  dc [-V] [--version] [-h] [--help] [-e scriptexpression ] 
    [--expression = scriptexpression ] [-f scriptfile ] [--file = scriptfile ] 
    [ arquivo ...]

Opções

Se algum parâmetro da linha de comandos permanecer após o processamento acima, esses parâmetros serão interpretados como os nomes dos arquivos de entrada a serem processados. Um nome de arquivo ” – ” (traço ou hífen) refere-se ao fluxo de entrada padrão. A entrada padrão será processada se nenhum arquivo ou expressão de script for especificado.

Comandos de impressão

Aritmética

A maioria das operações aritméticas é afetada pelo “valor de precisão”, que você pode definir com o comando k . O valor de precisão padrão é zero, o que significa que toda aritmética, exceto a adição e subtração, produz resultados inteiros.

Controle de pilha

Registros

dc fornece pelo menos 256 registros de memória, cada um nomeado por um único caractere. Você pode armazenar um número ou uma string em um registro e recuperá-lo mais tarde.

Cada registro também contém sua própria pilha. O valor atual do registro é o topo da pilha do registro.

Parâmetros

dc possui três parâmetros que controlam sua operação: a precisão, o radical de entrada e o radical de saída. A precisão especifica o número de dígitos da fração a serem mantidos no resultado da maioria das operações aritméticas. O radical de entrada controla a interpretação dos números digitados; todos os números digitados usam esse radical. O radix de saída é usado para imprimir números.

As radias de entrada e saída são parâmetros separados; você pode torná-los desiguais, o que pode ser útil ou confuso. O radical de entrada deve estar entre 2 e 16, inclusive. O radix de saída deve ser pelo menos 2. A precisão deve ser zero ou maior. A precisão é sempre medida em dígitos decimais, independentemente da corrente de entrada ou saída atual.

Cordas

o dc tem uma capacidade limitada de operar tanto em cadeias quanto em números; as únicas coisas que você pode fazer com as strings são imprimi-las e executá-las como macros (o que significa que o conteúdo da string é processado como comandos dc ). Todos os registradores e a pilha podem conter seqüências de caracteres, e o dc sempre sabe se algum objeto é uma sequência ou um número. Alguns comandos, como operações aritméticas, exigem números como argumentos e erros de impressão, se houver seqüências de caracteres. Outros comandos podem aceitar um número ou uma string; por exemplo, o comando p pode aceitar um e imprimir o objeto de acordo com seu tipo.

As macros geralmente são armazenadas em registros; [1p] sa armazena uma macro para imprimir 1 no registro a e lax chama essa macro.

Consulta de status

Diversos

Observe que cada instância empilhada de um registro possui sua própria matriz associada. Assim, 1 0: a 0Sa 2 0: a La 0; ap imprimirá 1 , porque o 2 foi armazenado em uma instância de 0: a que foi posteriormente exibida.

Exemplos

Primeiro, na linha de comando, vamos entrar na calculadora da área de trabalho.

  dc

Parece que nada aconteceu. O prompt do dc é apenas uma linha em branco e está pronto para receber nossos comandos. Primeiro, vamos colocar um número na pilha. Que tal 1234 :

  1234

Mais uma vez, nada parece ter acontecido. Vamos usar f para examinar todo o conteúdo da pilha:

  f

Isso imprime o seguinte:

  1234

Portanto, o 1234 está na pilha e pronto para ser operado. Aqui vamos multiplicá-lo por 2 e imprimir o resultado. dc usa a notação polonês reverso (postfix), que coloca os operandos em primeiro lugar e os operadores em segundo. O comando abaixo em inglês diz: “Pegue o item superior da pilha, opere com o número dois, usando a multiplicação da operação e imprima o resultado”. O comando é:

  2 * p

Isso pega nosso item 1234 da pilha superior, multiplica por 2 e imprime o valor resultante:

  2468

Ótimo. Agora vamos subtrair 468 e imprimir o resultado:

  468 - p

  2000

Lembre-se de que, se não estivéssemos colocando p no final do comando, o mesmo aconteceria, mas sem saída. Ok, agora vamos dividir (” / “) nosso resultado 2000 por 2 e imprimir o resultado:

  2 / p

  1000

E agora vamos pegar a raiz quadrada:

  vp

  31

Como a precisão padrão é 0 (calcule zero casas após o ponto decimal) e não a alteramos, o resultado foi arredondado para o número inteiro mais próximo. A resposta está realmente mais próxima de 31,62. Para obter uma resposta mais precisa, temos que dizer ao dc para usar maior precisão. Vamos dizer para ele calcular para dez lugares usando o comando k :

  10 mil 1000 vp

  31.6227766016

Aqui, combinamos várias operações em um comando. O comando fez o seguinte, na seguinte ordem:

1. empurrou 10 para a pilha,
2. mandou k tirar o número da pilha e definir a precisão com tantas casas decimais,
3. colocou 1000 na pilha,
4. disse a v para tirar 1000 da pilha, calcular a raiz quadrada e empurrar o resultado para a pilha, e
5. imprimiu o resultado com p .

Se quiséssemos, poderíamos definir a precisão para algo ridículo como 100000000, mas isso pode levar horas para ser calculado, e temos coisas melhores para fazer.

Vamos olhar a pilha um pouco mais de perto. Lembre-se, a pilha é como uma pilha de itens. Se você colocar um item na pilha, ele estará no topo. Se você retirar um item da pilha, retira o item superior (enviado mais recentemente) da pilha.

Primeiro, vamos limpar a pilha:

  c

Para garantir que foi limpo, vamos imprimir o item superior da pilha com o comando p :

  p

  dc: pilha vazia

Agora, vamos colocar dois itens na pilha. Digamos 1 e 2 .

  1
 2

Se usarmos o comando p , ele mostrará o item no topo da pilha. Aqui, esse será o item enviado mais recentemente, 2 :

  p

  2

Ou, podemos usar o comando f para exibir todo o conteúdo da pilha. Isso mostrará os itens de cima para baixo, em outras palavras, os mais recentes empurrados primeiro:

  f

  2
 1

Agora vamos operar na pilha. Vamos adicionar os dois itens principais e imprimir o resultado:

  + p

  3

Agora vamos ver o conteúdo completo da pilha usando f :

  f

  3

Os números 1 e 2 se foram. Ambos foram retirados da pilha pela operação de adição, que os juntou e empurrou o resultado, 3 , para a pilha.

Ao adicionar números, como acabamos de fazer, a ordem dos operandos não importa (1 + 2 é o mesmo que 2 + 1). Vamos usar a divisão agora, para ilustrar a ordem em que os itens da pilha são usados. Primeiro, vamos definir a precisão para duas casas decimais:

  2 k

Agora vamos limpar a pilha e pressionar 1 e 2 na pilha:

  c 1 2

Vamos verificar a pilha bem rápido:

  f

  2
 1

Agora vamos dividir e imprimir o resultado:

  / p

  .50

Como você pode ver, este é o resultado de 1 dividido por 2 , e não o contrário.

Nós terminamos por enquanto, então vamos sair do dc :

  q

O que nos leva ao prompt de comando do shell .

Comandos relacionados

bc – Uma calculadora.