producing an integer by shifting a bit. How far can I go?
Até que a representação de número inteiro seja envolvida (o padrão na maioria dos shells).
Um inteiro de 64 bits geralmente envolve 2**63 - 1 .
Isso é 0x7fffffffffffffff ou 9223372036854775807 no dec.
Esse número "+1" se torna negativo.
Isso é o mesmo que 1<<63 , assim:
$ echo "$((1<<62)) $((1<<63)) and $((1<<64))"
4611686018427387904 -9223372036854775808 and 1
Depois disso, o processo é repetido novamente.
$((1<<80000)) $((1<<1022)) $((1<<1023)) $((1<<1024)) $((1<<1025)) $((1<<1026))
O resultado depende do mod 64 do valor de deslocamento [a] .
[a] De: A contagem é mascarada para 5 bits (ou 6 bits se em 64- modo de bit e REX.W é usado). O intervalo de contagem é limitado a 0 a 31 (ou 63, se o modo de 64 bits e o REX.W forem usados). .
Além disso, lembre-se de que $((1<<0)) é 1
$ for i in 80000 1022 1023 1024 1025 1026; do echo "$((i%64)) $((1<<i))"; done
0 1
62 4611686018427387904
63 -9223372036854775808
0 1
1 2
2 4
Então, tudo depende de quão perto está o número para um múltiplo de 64.
Testando o limite:
A maneira robusta de testar qual é o número inteiro positivo máximo (e negativo) é testar cada bit um por vez. Em menos de 64 passos para a maioria dos computadores, não será muito lento.
bash
Primeiro, precisamos do maior inteiro do formulário 2^n (conjunto de 1 bit seguido de zeros). Podemos fazer isso mudando para a esquerda até o próximo turno tornar o número negativo, também chamado de "contorno":
a=1; while ((a>0)); do ((b=a,a<<=1)) ; done
Onde b é o resultado: o valor antes do último turno que falha no loop.
Em seguida, precisamos tentar cada detalhe para descobrir quais afetam o sinal de e :
c=$b;d=$b;
while ((c>>=1)); do
((e=d+c))
(( e>0 )) && ((d=e))
done;
intmax=$d
O inteiro máximo ( intmax ) resulta do último valor de d .
No lado negativo (menos de 0 ), repetimos todos os testes, mas testamos quando um bit poderia ser feito 0 sem envolver.
Um teste completo com impressão de todos os passos é este (para bash):
#!/bin/bash
sayit(){ printf '%020d 0x%016x\n' "$1"{,}; }
a=1; while ((a>0)) ; do((b=a,a<<=1)) ; sayit "$a"; done
c=$b;d=$b; while((c>>=1)); do((e=d+c));((e>0))&&((d=e)) ; sayit "$d"; done;
intmax=$d
a=-1; while ((a<0)) ; do((b=a,a<<=1)) ; sayit "$b"; done;
c=$b;d=$b; while ((c<-1)); do((c>>=1,e=d+c));((e<0))&&((d=e)); sayit "$d"; done
intmin=$d
printf '%20d max positive value 0x%016x\n' "$intmax" "$intmax"
printf '%20d min negative value 0x%016x\n' "$intmin" "$intmin"
sh
Traduzido para praticamente qualquer shell:
#!/bin/sh
printing=false
sayit(){ "$printing" && printf '%020d 0x%016x\n' "$1" "$1"; }
a=1; while [ "$a" -gt 0 ];do b=$a;a=$((a<<1)); sayit "$a"; done
c=$b;d=$b; while c=$((c>>1)); [ "$c" -gt 0 ];do e=$((d+c)); [ "$e" -gt 0 ] && d=$e ; sayit "$d"; done;
intmax=$d
a=-1; while [ "$a" -lt 0 ];do b=$a;a=$((a<<1)); sayit "$b"; done;
c=$b;d=$b; while [ "$c" -lt -1 ];do c=$((c>>1));e=$((d+c));[ "$e" -lt 0 ] && d=$e ; sayit "$d"; done
intmin=$d
printf '%20d max positive value 0x%016x\n' "$intmax" "$intmax"
printf '%20d min negative value 0x%016x\n' "$intmin" "$intmin"
Executando o acima para muitos shells,
todos (exceto bash 2.04 e mksh) aceitaram valores até ( 2**63 -1 ) neste computador.
É interessante informar que o shell do att :
$ attsh --version
version sh (AT&T Research) 93u+ 2012-08-01
imprimiu um erro nos valores de $((2^63)) , mas não no ksh.