Converter valores de dalton para kilodalton (dividir valores por 1000)

Question

Como podemos converter valores dalton em kilodalton usando comandos shell? Eu tenho uma lista de valores em daltons . Existem 1000 daltons em um kilodalton, então é necessário dividir cada valor em mil.

Dados da amostra:

12345.09
236575.665
18865.41
45678.87

Saída desejada:

12.34509
236.575665
18.86541
45.67887

    

Answer 1

Com awk

A tarefa aqui é simplesmente dividir cada valor por mil. Existem várias maneiras de fazer isso - em todos os valores em seu arquivo - com apenas um único comando. Suponha que seus números estejam em um arquivo chamado dalton.txt e, como no exemplo mostrado, sejam um valor por linha. Aqui está uma maneira, usando o AWK:

awk '{ print $0 / 1000.0 }' dalton.txt

Isso opera em cada linha. $0 no AWK indica a linha inteira. Conforme escrito, o resultado é o seu terminal, mas você pode redirecionar a saída para um arquivo . Isso envia a saída para kilodalton.txt (sobrescrevendo-a se já existir):

awk '{ print $0 / 1000.0 }' dalton.txt > kilodalton.txt

No entanto, você pode querer personalizar a precisão. Dado o exemplo de entrada que você nos mostrou, a saída para o seu terminal ou o arquivo usando esses comandos é:

12.3451
236.576
18.8654
45.6789

Como exemplo de saída, cada valor de saída mantém a mesma precisão (em termos do número de dígitos da informação mostrada) que o valor de entrada correspondente. Se você quiser isso:

awk '{ printf "%.*g\n", length($0), $0 / 1000.0 }' dalton.txt

Isso ainda trunca os zeros à direita após o ponto decimal, pois é assim que a função printf g especificador de formato se comporta. (Seus exemplos não deixam claro se você quiser isso.) O modo como funciona é simplesmente especificar uma precisão que seja sempre pelo menos tão alta quanto o número de dígitos na entrada, mas fazendo com que seja o comprimento total da linha de entrada. length($0) .

Esse comando também pode ser redirecionado para um arquivo, e sua saída é exatamente a saída mostrada na sua pergunta:

12.34509
236.575665
18.86541
45.67887

Muitas vezes você pode querer especificar a mesma precisão para cada entrada, seja como o número total de figuras mostradas ou como o número de figuras mostradas após o ponto decimal. Por exemplo, para mostrar um total de 6 valores para cada valor (a primeira linha será 12.3451 ), use:

awk '{ printf "%.6g\n", $0 / 1000.0 }' dalton.txt

Ou para mostrar 3 números após a casa decimal para cada valor (a primeira linha será 12.345 ) use:

awk '{ printf "%.3f\n", $0 / 1000.0 }' dalton.txt

Embora seja possível escrever um loop em um script de shell que leia os dados, isso é mais complicado e raramente é a melhor abordagem quando um comando simples faz isso para você . Mesmo que isso já faça parte de um script de shell maior, os shells são idiomas de cola que devem ser usados para chamadas Quaisquer ferramentas são mais adequadas para uma tarefa. Por isso, sugiro usar esse método awk , o excelente perl method do terdon como.

    

Answer 2

Gostaria apenas de usar perl :

$ perl -lne 'print $_/1000' file
12.34509
236.575665
18.86541
45.67887

Ou awk :

$ awk '{printf "%.6f\n", $1/1000}' file
12.345090
236.575665
18.865410
45.678870

    

Answer 3

Descrição geral

Suponha que o valor numérico esteja armazenado na variável dalton . Em seguida, ele trabalha com valores grandes o suficiente para criar valores diferentes de zero com a construção simples $(()) .

Exemplo:

$ dalton=3800
$ echo $(($dalton/1000))
3

Para obter o arredondamento correto para o inteiro mais próximo

$ echo $(( ($dalton+500)/1000 ))
4

Você tem mais recursos se instalar bc .

sudo apt-get install bc

$ bc
bc 1.06.95
Copyright 1991-1994, 1997, 1998, 2000, 2004, 2006 Free Software Foundation, Inc.
This is free software with ABSOLUTELY NO WARRANTY.
For details type 'warranty'. 
scale=3                        # set the number of decimals
dalton=3800
dalton/1000
3.800
(dalton+0,5)/1000
(standard_in) 4: syntax error  # use decimal point (not comma)
(dalton+0.5)/1000              # add 0.5 to get correct rounding
3.800
dalton=3800.8
(dalton+0.5)/1000
3.801
dalton=3800.2
(dalton+0.5)/1000
3.800
quit
$ 

Em um shellscript você pode canalizar a entrada em bc assim,

echo "scale=3
($dalton+0.5)/1000" | bc

O que também pode ser testado de forma interativa,

$ dalton=3800.8
$ echo "scale=3
($dalton+0.5)/1000" | bc
3.801
$

Shellscript

Crie um script com o nome converter

#!/bin/bash

dalton=

function convert2kilo {

 echo "scale=6
 ($dalton+0.0005)/1000" | bc 
}
########################################################################

# main

########################################################################

while read dalton
do
 convert2kilo
done

e um arquivo de entrada com o nome input.data

12345.09
236575.665
18865.41
45678.87
1.0008
1.0002

Faça o executável do shellscript

chmod ugo+x converter

Execute o shellscript

$ < input.data ./converter 
12.345090
236.575665
18.865410
45.678870
.001001
.001000
$ 

    

Answer 4

Este pequeno script seria útil:

#!/bin/bash    

values="$1"

echo "Source of values: $values"

while read -e name; do            

        results=$(bc <<< "scale=4; ($name/1000)")
        echo "$results"

done < "$values"

Uso:

1. Torne o arquivo executável com:

   chmod u+x dalton.sh
   

2. Execute e passe o caminho para o arquivo de dados ou nome do arquivo:

   ./dalton.sh data.txt
   

Answer 5

Vamos supor que você tenha um arquivo de texto chamado daltons , por exemplo, com todos os valores numéricos que deseja converter, em uma única coluna.

awk '{kDa=$1/1000; print kDa}' daltons >> result

Em que kDa é uma variável para armazenar a operação e $1 terá cada um dos valores da linha. Finalmente, os resultados são armazenados no arquivo result .