7,5 * 2 resulta em 15, com um ponto final. Como posso me livrar disso?

Para se livrar do ponto final, use a ${name%pattern}forma de expansão de parâmetro .

echo ${$(( width * 2 ))%.}

Isso não ajudará se o resultado não for um número inteiro devido a aproximações.

echo $(((0.1 + 0.2) * 10))
3.0000000000000004

Se você não gosta desse resultado:

1. Leia o que todo programador deve saber sobre aritmética de ponto flutuante
2. Se você ainda quiser usar ponto flutuante e ainda não gostar do resultado, vá para 1.

zshé um dos três shells do tipo Bourne (com ksh93 e yash) que suportam aritmética de números inteiros e aritmética de ponto flutuante em suas expressões aritméticas (dentro de (( ... )), e a maioria dos componentes internos que aceitam números como argumentos, como em ksh $(( ... )), ${array[...]}de onde vêm esses recursos).

Essas expressões aritméticas são moldadas de acordo com a linguagem C e seguem basicamente as mesmas regras¹. Em particular, uma operação que envolve apenas números inteiros produz um número inteiro. E assim que houver um carro alegórico, há uma promoção para o carro alegórico.

Como em C, um literal numérico é considerado ponto flutuante se contiver a .ou usar a notação de engenharia ( 1e-2...) ou for uma das variantes de NaN ou Infinity² e inteiro caso contrário, portanto, anexar a .a uma sequência de dígitos decimais é a maneira mais fácil de garantir que ela seja considerada uma constante flutuante em vez de uma constante inteira.

Por exemplo, em C como em zsh/ksh93³/yash, 2 / 4 * 6.produz 0. porque produz o inteiro2 / 4 0 e produz o float.0 * 6.0.

Embora 2. / 4 * 6produza 3.porque 2. / 4é uma operação de ponto flutuante porque pelo menos um dos operandos é um ponto flutuante que produz 0,5 e 0.5 * 6também é uma operação flutuante.

$ print -rl  '#include <stdio.h>' 'int main() {printf("%.17g\n", 2 / 4 * 6.);}' | tcc -run -
0
$ print -rl  '#include <stdio.h>' 'int main() {printf("%.17g\n", 2. / 4 * 6);}' | tcc -run -
3

O mesmo em ksh93:

$ print "$(( 2 / 4 * 6. ))"
0
$ print "$(( 6. * 2 / 4 ))"
3

Ou zsh:

$ print $(( 2 / 4 * 6. ))
0.
$ print $(( 6. * 2 / 4 ))
3.

Exceto que zshpreserva a informação de que a expressão gerou um float adicionando that .. Não acrescenta isso .se o número já for uma representação flutuante por outros motivos, como:

$ print $(( 1./0 )) $(( 0./0 )) $(( 10. ** 20 ))
Inf NaN 1e+20

De forma mais geral, quando zsh fornece uma representação de texto decimal de um número de ponto flutuante (que ele armazena internamente como o doubletipo C), ele tenta fornecer uma representação completamente fiel, de modo que, se for usado posteriormente em outra expressão aritmética, não há perda de informações, incluindo tipo (inteiro versus flutuante) e precisão.

É por isso que além de adicionar isso .para desambiguar float de inteiros, ele usa o %.17g sprintf()formato ao calcular a representação de texto inteiro decimal do número, já que 17 dígitos é o número mínimo de dígitos decimais necessários no caso geral para garantir a precisão total de um 64 bits O número binário de precisão dupla IEEE 754 é mantido. E tanta precisão tem a desvantagem de expor os erros incorridos na conversão entre decimal e binário.

Isso é discutido detalhadamente em Por que $((0.1)) se expande para 0,1000000000000001 em zsh?

Agora, para consumo humano, você geralmente não precisa ver isso .para saber que é para ser um número de ponto flutuante, não que você se importe se é para ser ou não. E você não precisa ter tanta precisão, então, para fins de exibição e apenas para consumo humano, é melhor usar printfou print -fformatar o número.

printf '%g\n' width
print -f '%g\n' width

Imprimiria o valor da largura formatado da mesma forma que, awkpor exemplo, formataria-o com 6 dígitos de precisão (também mudando para 9.9999e-05ou 1e06para números abaixo de 1e-4 ou acima de 1e6)

$ printf '%1$25s: %1$g\n' 0.1 0.1000001 $((0.1)) 1000000 '1e-4 - 1e-9' $(( 1e-4  -1e-9 ))
                      0.1: 0.1
                0.1000001: 0.1
      0.10000000000000001: 0.1
                  1000000: 1e+06
              1e-4 - 1e-9: 9.9999e-05
   9.9999000000000003e-05: 9.9999e-05

$ awk 'BEGIN {print 0.1, 0.10000001, 1000000, 1000000.1, 1e-4 - 1e-9}'
0.1 0.1 1000000 1e+06 9.9999e-05

Aqui com a diferença de que os números não passam pelo OFMTformato se forem considerados inteiros.

Usar:

printf '%.17g\n' width

Se você deseja preservar o máximo de precisão possível e ao mesmo tempo remover os .números que não possuem parte decimal.

Assim como no ksh, também é possível declarar uma variável com:

typeset -F2 x
typeset -E6 y

Para $xser expresso em notação de ponto flutuante com 2 dígitos após o ponto final quando expandido (como na %.2f printfdiretiva) e $ypara ser expresso em notação de engenharia com 6 dígitos significativos (como na %.6e printfdiretiva), mas não acho que haja um equivalente para %g.

Observe que o valor da variável ainda é armazenado internamente com total precisão, esses atributos -F/ -Eafetam apenas as expansões.

$ typeset -F2 x
$ typeset -E6 y
$ x=0.123456789
$ echo $x
0.12
$ echo $((x))
0.123456789
$ y=x
$ echo $y
1.23457e-01

^{¹ Exceto zshao contrário, ksh tem algumas incompatibilidades quando se trata de precedência de operador, embora isso não seja relevante para esta questão.}

^{² Observe que, ao contrário de ksh93, yash ou C99, ele não suporta hexadecimais de ponto flutuante, como 0xDead.Beefou 0x123p-4ainda.}

^{³ Tenha cuidado, pois ksh93 respeita o caractere de raiz decimal do código do idioma; em um local onde está em ,vez de ., isso teria que ser escrito2 / 4 * 6,}