como arredondar números após vírgula sempre

Vamos supor que seus números estejam em um arquivo numberse que o seu localeseja usado ,como ponto decimal, como fr_FR.UTF-8. Também adicionei 10000000000como um dos seus números de origem para demonstrar que o arredondamento não ocorre para resultados inteiros:

export LC_ALL=fr_FR.UTF-8                # Change my locale

awk '
    {
        n=$1*1.03;                       # Multiply input value
        printf "%d\t%f\t", $1, n;        # DEBUG: show input and multiplied values
        if (n>int(n)) { n=int(n)+1 };    # Round up +ve if not an integer value
        print n;                         # Output integer result
    }
' numbers

Se os números de entrada puderem ser negativos, o código de arredondamento precisará ser mais complexo para arredondar a partir de zero. Deixe-me saber se isso pode ser um problema e incluirei um código para resolvê-lo.

Resultado, incluindo as colunas de depuração, usando seus dados

3073771824      3165984978.720000       3165984979
1513517589      1558923116.670000       1558923117
4982173058      5131638249.740000       5131638250
1539400944      1585582972.320000       1585582973
3175320163      3270579767.890000       3270579768
5247018359      5404428909.770000       5404428910
14359014635     14789785074.050001      14789785075
10000000000     10300000000.000000      10300000000

Resultado sem depuração, usando seus dados

3165984979
1558923117
5131638250
1585582973
3270579768
5404428910
14789785075
10300000000

Remova ou comente a printflinha para remover as duas colunas de depuração. Você pode travar o awkcomando em uma única linha, se necessário, removendo os comentários e concatenando as linhas restantes.

Agora, em relação ao local. O awkprograma espera que suas constantes numéricas sejam usadas .como ponto decimal, independentemente da localidade; este é um requisito sintático. Por exemplo, print 3,1imprime dois valores separados por um espaço ( 3 1), mas print 3.1imprime um único valor decimal ( 3.1).

Se você estiver usando GNU, gawkvocê pode especificar o -Nsinalizador ( --use-lc-numeric) para que ele leia e grave valores de dados e converta strings em números usando sua localidade:

echo 1000 1,3005 | gawk -N '{ print $1 * $2 }'
1300,5

echo 1000 | gawk -N '{ print "1,03" * $1 }'
1030

No entanto, na sua pergunta você está lendo e escrevendo valores inteiros, portanto o ponto decimal da localidade não é relevante.

Usando Moleiro :

$ mlr --nidx put '$1 = round($1 * 1.03)' file

Para arredondar números para o número inteiro superior, o seguinte comando pode ser usado.

$ mlr --nidx put '$1 = ceil($1 * 1.03)' file

Para ser claro, na echo 2.5 | awk '{print int($1+0.5)}'sua pergunta, esse código awk não está arredondando para cima3 , está adicionando 0.5e arredondando para baixo para 3 (mas já é 3, então int()na verdade não está arredondando). Se você começasse com 2.4em vez de 2.5o resultado seria 2, não 3como você esperaria do arredondamento, porque int()sempre arredonda para baixo.

Usando qualquer awk:

$ awk '
    function ceil(x,   y) { y=int(x); return(x>y ? y+1 : y) }
    { print ceil($0 * 1.03) }
' file
3165984979
1558923117
5131638250
1585582973
3270579768
5404428910
14789785075

Se você usar ,em vez de .como ponto decimal em sua localidade, é possível usar 1,03em vez de 1.03em seu cálculo, mas eu não recomendaria (recomendo usar LC_ALL=Cpor padrão), pois isso requer código diferente em diferentes variantes do awk e não é tão simples quanto parece, por exemplo, com GNU awk precisamos adicionar -Npara dizer ao gawk para usar sua localidade para isso, e então escrever 1,03como uma string "1,03"em vez de um número literal e confiar em usá-lo em um contexto aritmético (multiplicando) para converta-o em um número porque um literal ,significa coisas diferentes em um script awk:

$ LC_ALL='fr_FR' awk -N '
    function ceil(x,   y) { y=int(x); return(x>y ? y+1 : y) }
    { print ceil($0 * "1,03") }
' file
3165984979
1558923117
5131638250
1585582973
3270579768
5404428910
14789785075

Consulte https://www.gnu.org/software/gawk/manual/gawk.html#Locale-influences-conversions para obter mais informações sobre isso.

Em geral, porém, o que você está pedindo é uma função ceil()(para " teto ") conforme mostrado acima. É importante incluir zero e números negativos em seu exemplo quando você estiver procurando por qualquer tipo de função de arredondamento, pois é fácil errar, usando este arquivo de entrada:

$ cat file
1.999999
1.0
0.000001
0
-0.000001
-1.0
-1.999999

podemos testar uma ceil()função:

$ awk 'function ceil(x, y){y=int(x); return(x>y?y+1:y)} {print $0,ceil($0)}' file
1.999999 2
1.0 1
0.000001 1
0 0
-0.000001 0
-1.0 -1
-1.999999 -1

e a floor()função oposta:

$ awk 'function floor(x, y){y=int(x); return(x<y?y-1:y)} {print $0,floor($0)}' file
1.999999 1
1.0 1
0.000001 0
0 0
-0.000001 -1
-1.0 -1
-1.999999 -2

O acima funciona porque int()trunca em direção a zero (do manual GNU awk):

int(x)
    Return the nearest integer to x, located between x and zero and
    truncated toward zero. For example, int(3) is 3, int(3.9) is 3,
    int(-3.9) is -3, and int(-3) is -3 as well.

então int(), um número negativo já faz o que você deseja para uma função teto, ou seja, arredondar para cima, e você só precisa adicionar 1 ao resultado se int()arredondar para baixo um número positivo.

Usei 0.000001, etc. nas amostras para evitar que as pessoas obtivessem um falso positivo testando uma solução que adiciona algum número como 0.9e depois int()ing.

Observe também que ceil()pode ser abreviado para:

function ceil(x){return int(x)+(x>int(x))}

mas escrevi como acima para maior clareza (não está claro/óbvio se o resultado x>int(x)é 1 ou 0) e eficiência (ligue apenas int()uma vez em vez de duas).

você poderia usar um script no qual os números são sua entrada. Aqui está um exemplo de uma função que ajudaria.

for number in "${numbers[@]}"; do
  result=$(awk -v num="$number" 'BEGIN { printf "%d\n", (num * 1.03 == int(num * 1.03) ? num * 1.03 : int(num * 1.03) + 1) }')

  echo "$result"

done

Certamente sou inclinado a usar Perl, já que muitas vezes é minha ferramenta preferida para fazer coisas, mas sem usar o próprio Bash ou ferramentas mais simples como bc, que não lidam com arredondamentos nativamente (é claro que ainda pode ser facilmente implementado, mas ainda assim), Perl pode ter a maneira mais simples de usar ceil()a partir do POSIXmódulo. Devido à forma como o Perl funciona, o preenchimento que aparentemente lidera os números será tratado de forma automática e elegante:

perl -MPOSIX -lne 'print(ceil($_ * 1.03))' file

% cat file
 3073771824
 1513517589
 4982173058
 1539400944
 3175320163
 5247018359
14359014635
% perl -MPOSIX -lne 'print(ceil($_ * 1.03))' file
3165984979
1558923117
5131638250
1585582973
3270579768
5404428910
14789785075

Se desejar preservar o preenchimento (você precisará ajustar 11se os números resultantes tiverem mais de 11 dígitos):

perl -MPOSIX -ne 'printf("%11d\n", ceil($_ * 1.03))' file

% perl -MPOSIX -ne 'printf("%11d\n", ceil($_ * 1.03))' file
 3165984979
 1558923117
 5131638250
 1585582973
 3270579768
 5404428910
14789785075

Usando Raku (anteriormente conhecido como Perl_6)

~$ raku -ne 'put ceiling($_ * 1.03)'   file

#OR

~$ raku -ne 'ceiling($_ * 1.03).put'   file

#OR

~$ raku -ne '($_ * 1.03).ceiling.put'  file

Raku pode ser usado de maneira semelhante à excelente resposta Perl de @kos. A rotina do Raku ceilingé integrada, portanto nenhum módulo precisa ser chamado na linha de comando. A putchamada adiciona um terminador de nova linha para você e, no primeiro exemplo, parênteses extras putnão são necessários.

Entrada de amostra:

 3073771824
+3073771824
-3073771824
 1513517589
 4982173058
 1539400944
 3175320163
 5247018359
14359014635

Saída de amostra:

3165984979
3165984979
-3165984978
1558923117
5131638250
1585582973
3270579768
5404428910
14789785075

Isso levanta a questão do que fazer se um número não-inteiro for encontrado na entrada. Ignorar essa linha é o mais fácil, mas (se isso causar desalinhamento dos dados colunares), um espaço reservado como "NaN" pode ser usado. Ambas as correções demonstradas abaixo (coagir +$_e testar):

~$ printf '3073771824\n' | raku -ne 'ceiling($_ * 1.03).put;'
3165984979
~$ printf '3073771824\n' | raku -ne 'ceiling($_ * 1.03).put if +$_;'
3165984979


~$ printf '3073771824A\n' | raku -ne 'ceiling($_ * 1.03).put;'
Cannot convert string to number: trailing characters after number in '3073771824⏏A' (indicated by ⏏)
  in block <unit> at -e line 1

~$ printf '3073771824A\n' | raku -ne 'ceiling($_ * 1.03).put if +$_; #no error (line is skipped)'
~$ printf '3073771824A\n' | raku -ne ' +$_ ?? ($_ * 1.03).ceiling.put !! "NaN".put;'
NaN
~$

https://docs.raku.org/routine/ceiling
https://raku.org

Já faz muito, muito tempo desde que usei awk, e já faz mais tempo ainda desde que aprendi matemática de números inteiros.

Você terá que verificar se seus números não ultrapassam os limites, mas...

x = ((x * 103) + 99) / 100

fornecerá um valor inteiro que é 103% do número inteiro x arredondado para cima .

Se você precisar arredondar de zero e puder ter valores negativos para começar, use alguma lógica para subtrair 99 em vez de adicionar 99 (para valores positivos).

Exemplos simples:

1.03% of 50:
 50 * 103 = 5150  ||  5150 + 99 = 5249  ||  5249 / 100 = 52 (integer div aka truncation)

1.03% of 100:
100 * 103 = 10300  ||  10300 + 99 = 10399  ||  10399 / 100 = 103 (no surprise)

1.03% of 101:
101 * 103 = 10403  ||  10403 + 99 = 10502  ||  10502 / 100 = 105 (104.03 ==> 105)

Experimente você mesmo com alguns números.

Além disso, consulte utilitários dce bcdois programas de calculadora simples . Para uma transformação de dados simples como essa, isso pode ser ainda mais fácil do que lidar com a riqueza do awk.