Tôi đang cố gắng phân chia hai chiều rộng hình ảnh trong tập lệnh Bash, nhưng 0kết quả là bash cho tôi :

RESULT=$(($IMG_WIDTH/$IMG2_WIDTH))

Tôi đã nghiên cứu hướng dẫn Bash và tôi biết tôi nên sử dụng bc, trong tất cả các ví dụ trên internet họ sử dụng bc. Trong echotôi đã cố gắng đặt điều tương tự vào tôi SCALEnhưng nó không hoạt động.

Đây là ví dụ tôi tìm thấy trong các hướng dẫn:

echo "scale=2; ${userinput}" | bc 

Làm thế nào tôi có thể khiến Bash cho tôi một cái phao như thế 0.5nào?

Bạn không thể. bash chỉ làm số nguyên; bạn phải ủy thác cho một công cụ như bc.

bạn có thể làm được việc này:

bc <<< 'scale=2; 100/3'
33.33

CẬP NHẬT 20130926 : bạn có thể sử dụng:

bc -l <<< '100/3' # saves a few hits

bash

Như những người khác lưu ý, bashkhông hỗ trợ số học dấu phẩy động, mặc dù bạn có thể giả mạo nó bằng một số thủ thuật thập phân cố định, ví dụ với hai số thập phân:

echo $(( 100 * 1 / 3 )) | sed 's/..$/.&/'

Đầu ra:

.33

Xem câu trả lời của Nilfred cho cách tiếp cận tương tự nhưng ngắn gọn hơn.

Lựa chọn thay thế

Bên cạnh các đề cập bcvà giải awkpháp thay thế cũng có những điều sau đây:

clisp

clisp -x '(/ 1.0 3)'

với đầu ra được làm sạch:

clisp --quiet -x '(/ 1.0 3)'

hoặc thông qua stdin:

echo '(/ 1.0 3)' | clisp --quiet | tail -n1

đc

echo 2k 1 3 /p | dc

máy tính thiên tài cli

echo 1/3.0 | genius

bản thảo

echo 1 3 div = | gs -dNODISPLAY -dQUIET | sed -n '1s/.*>//p' 

gnuplot

echo 'pr 1/3.' | gnuplot

jq

echo 1/3 | jq -nf /dev/stdin

Hoặc là:

jq -n 1/3

ksh

echo 'print $(( 1/3. ))' | ksh

lua

lua -e 'print(1/3)'

hoặc thông qua stdin:

echo 'print(1/3)' | lua

cực đại

echo '1/3,numer;' | maxima

với đầu ra được làm sạch:

echo '1/3,numer;' | maxima --quiet | sed -En '2s/[^ ]+ [^ ]+ +//p'

nút

echo 1/3 | node -p

quãng tám

echo 1/3 | octave

perl

echo print 1/3 | perl

trăn2

echo print 1/3. | python2

trăn3

echo 'print(1/3)' | python3

R

echo 1/3 | R --no-save

với đầu ra được làm sạch:

echo 1/3 | R --vanilla --quiet | sed -n '2s/.* //p'

hồng ngọc

echo print 1/3.0 | ruby

wcalc

echo 1/3 | wcalc

Với đầu ra được làm sạch:

echo 1/3 | wcalc | tr -d ' ' | cut -d= -f2

zsh

echo 'print $(( 1/3. ))' | zsh

các đơn vị

units 1/3

Với đầu ra nhỏ gọn:

units --co 1/3

Những nguồn khác

Stéphane Chazelas đã trả lời một câu hỏi tương tự trên Unix.SX.

Cải thiện một chút câu trả lời của marvin:

RESULT=$(awk "BEGIN {printf \"%.2f\",${IMG_WIDTH}/${IMG2_WIDTH}}")

bc không đến luôn như gói cài đặt.

Bạn có thể sử dụng bc theo -ltùy chọn (chữ L)

RESULT=$(echo "$IMG_WIDTH/$IMG2_WIDTH" | bc -l)

Thay thế cho bc, bạn có thể sử dụng awk trong tập lệnh của mình.

Ví dụ:

echo "$IMG_WIDTH $IMG2_WIDTH" | awk '{printf "%.2f \n", $1/$2}'

Trong phần trên, "% .2f" cho biết hàm printf trả về số dấu phẩy động có hai chữ số sau vị trí thập phân. Tôi đã sử dụng echo để pipe trong các biến khi các trường vì awk hoạt động đúng trên chúng. "$ 1" và "$ 2" đề cập đến trường nhập thứ nhất và thứ hai vào awk.

Và bạn có thể lưu trữ kết quả như một số biến khác bằng cách sử dụng:

RESULT = `echo ...`

Đây là thời điểm hoàn hảo để thử zsh, một superset bash (gần như), với nhiều tính năng hay hơn bao gồm toán học dấu phẩy động. Đây là ví dụ của bạn sẽ như thế nào trong zsh:

% IMG_WIDTH=1080
% IMG2_WIDTH=640
% result=$((IMG_WIDTH*1.0/IMG2_WIDTH))
% echo $result
1.6875

Bài đăng này có thể giúp bạn: bash - Đáng chuyển sang zsh để sử dụng thông thường?

Chà, trước khi thả nổi là thời điểm sử dụng logic số thập phân cố định:

IMG_WIDTH=100
IMG2_WIDTH=3
RESULT=$((${IMG_WIDTH}00/$IMG2_WIDTH))
echo "${RESULT:0:-2}.${RESULT: -2}"
33.33

Dòng cuối cùng là một bashim, nếu không sử dụng bash, thay vào đó hãy thử mã này:

IMG_WIDTH=100
IMG2_WIDTH=3
INTEGER=$(($IMG_WIDTH/$IMG2_WIDTH))
DECIMAL=$(tail -c 3 <<< $((${IMG_WIDTH}00/$IMG2_WIDTH)))
RESULT=$INTEGER.$DECIMAL
echo $RESULT
33.33

Lý do đằng sau mã là: nhân với 100 trước khi chia để nhận 2 số thập phân.

Nếu bạn tìm thấy biến thể của sở thích của mình, bạn cũng có thể gói nó thành một hàm.

Ở đây tôi đang gói một số bashism vào một hàm div:

Lót:

function div { local _d=${3:-2}; local _n=0000000000; _n=${_n:0:$_d}; local _r=$(($1$_n/$2)); _r=${_r:0:-$_d}.${_r: -$_d}; echo $_r;}

Hoặc nhiều dòng:

function div {
  local _d=${3:-2}
  local _n=0000000000
  _n=${_n:0:$_d}
  local _r=$(($1$_n/$2))
  _r=${_r:0:-$_d}.${_r: -$_d}
  echo $_r
}

Bây giờ bạn có chức năng

div <dividend> <divisor> [<precision=2>]

và sử dụng nó như

> div 1 2
.50

> div 273 123 5
2.21951

> x=$(div 22 7)
> echo $x
3.14

CẬP NHẬT Tôi đã thêm một tập lệnh nhỏ cung cấp cho bạn các thao tác cơ bản với số dấu phẩy động cho bash:

Sử dụng:

> add 1.2 3.45
4.65
> sub 1000 .007
999.993
> mul 1.1 7.07
7.7770
> div 10 3
3.
> div 10 3.000
3.333

Và đây là kịch bản:

#!/bin/bash
__op() {
        local z=00000000000000000000000000000000
        local a1=${1%.*}
        local x1=${1//./}
        local n1=$((${#x1}-${#a1}))
        local a2=${2%.*}
        local x2=${2//./}
        local n2=$((${#x2}-${#a2}))
        local n=$n1
        if (($n1 < $n2)); then
                local n=$n2
                x1=$x1${z:0:$(($n2-$n1))}
        fi
        if (($n1 > $n2)); then
                x2=$x2${z:0:$(($n1-$n2))}
        fi
        if [ "$3" == "/" ]; then
                x1=$x1${z:0:$n}
        fi
        local r=$(($x1"$3"$x2))
        local l=$((${#r}-$n))
        if [ "$3" == "*" ]; then
                l=$(($l-$n))
        fi
        echo ${r:0:$l}.${r:$l}
}
add() { __op $1 $2 + ;}
sub() { __op $1 $2 - ;}
mul() { __op $1 $2 "*" ;}
div() { __op $1 $2 / ;}

Đó không thực sự là điểm nổi, nhưng nếu bạn muốn một cái gì đó đặt nhiều hơn một kết quả trong một lần gọi bc ...

source /dev/stdin <<<$(bc <<< '
d='$1'*3.1415926535897932384626433832795*2
print "d=",d,"\n"
a='$1'*'$1'*3.1415926535897932384626433832795
print "a=",a,"\n"
')

echo bc radius:$1 area:$a diameter:$d

tính diện tích và đường kính của hình tròn có bán kính bằng $ 1

Có những kịch bản trong đó bạn không thể sử dụng bc vì nó có thể đơn giản là không có mặt, như trong một số phiên bản rút gọn của busybox hoặc các hệ thống nhúng. Trong mọi trường hợp, việc giới hạn các phụ thuộc bên ngoài luôn là điều nên làm để bạn luôn có thể thêm các số 0 vào số được chia cho (tử số), tương tự như nhân với lũy thừa 10 (bạn nên chọn công suất 10 theo độ chính xác bạn cần), điều đó sẽ làm cho đầu ra phân chia thành một số nguyên. Khi bạn có số nguyên đó coi nó như một chuỗi và định vị dấu thập phân (di chuyển nó từ phải sang trái) một số lần bằng lũy ​​thừa của mười bạn nhân tử số với. Đây là một cách đơn giản để có được kết quả float bằng cách chỉ sử dụng số nguyên.

Trong khi bạn không thể sử dụng phân chia điểm nổi trong Bash, bạn có thể sử dụng phân chia điểm cố định. Tất cả những gì bạn cần làm là nhân số nguyên của bạn với lũy thừa 10 và sau đó tách phần nguyên và sử dụng phép toán modulo để lấy phần phân số. Làm tròn khi cần.

#!/bin/bash

n=$1
d=$2

# because of rounding this should be 10^{i+1}
# where i is the number of decimal digits wanted
i=4
P=$((10**(i+1)))
Pn=$(($P / 10))
# here we 'fix' the decimal place, divide and round tward zero
t=$(($n * $P / $d + ($n < 0 ? -5 : 5)))
# then we print the number by dividing off the interger part and
# using the modulo operator (after removing the rounding digit) to get the factional part.
printf "%d.%0${i}d\n" $(($t / $P)) $(((t < 0 ? -t : t) / 10 % $Pn))

tôi biết nó cũ, nhưng quá hấp dẫn. Vì vậy, câu trả lời là: bạn không thể ... nhưng bạn có thể. chúng ta hãy cố gắng này:

$IMG_WIDTH=1024
$IMG2_WIDTH=2048

$RATIO="$(( IMG_WIDTH / $IMG2_WIDTH )).$(( (IMG_WIDTH * 100 / IMG2_WIDTH) % 100 ))

như thế bạn có được 2 chữ số sau điểm, bị cắt cụt (gọi nó làm tròn xuống thấp hơn, haha) trong bash thuần (không cần phải khởi chạy các quy trình khác). Tất nhiên, nếu bạn chỉ cần một chữ số sau điểm bạn nhân với 10 và thực hiện modulo 10.

cái này làm gì

• $ đầu tiên ((...)) không phân chia số nguyên;
• giây $ ((...)) thực hiện phép chia số nguyên cho một số lớn hơn 100 lần, về cơ bản di chuyển 2 chữ số của bạn sang bên trái của điểm, sau đó (%) chỉ nhận cho bạn 2 chữ số đó bằng cách thực hiện modulo.

phần thưởng theo dõi : bc phiên bản x 1000 mất 1,8 giây trên máy tính xách tay của tôi, trong khi bản bash thuần mất 0,016 giây.

Cách thực hiện phép tính dấu phẩy động trong bash:

Thay vì sử dụng " chuỗi ở đây " ( <<<) với bclệnh, giống như một trong những ví dụ được nâng cấp nhất , đây là ví dụ vềbc dấu phẩy động yêu thích của tôi , ngay từ EXAMPLESphần của bctrang man (xemman bc phần hướng dẫn sử dụng).

Trước khi chúng ta bắt đầu, hãy biết rằng một phương trình cho pi là : pi = 4*atan(1). a()dưới đây là bchàm toán học cho atan().

1. Đây là cách lưu trữ kết quả của phép tính dấu phẩy động vào biến bash - trong trường hợp này là một biến được gọipi . Lưu ý rằng scale=10đặt số chữ số thập phân có độ chính xác là 10 trong trường hợp này. Bất kỳ chữ số thập phân sau khi nơi này được cắt ngắn .

   pi=$(echo "scale=10; 4*a(1)" | bc -l)

2. Bây giờ, để có một dòng mã cũng in ra giá trị của biến này, chỉ cần thêm echolệnh vào cuối dưới dạng lệnh tiếp theo, như sau. Lưu ý cắt ngắn ở 10 vị trí thập phân, như được chỉ huy:

   pi=$(echo "scale=10; 4*a(1)" | bc -l); echo $pi
   3.1415926532

3. Cuối cùng, hãy ném vào một số làm tròn. Ở đây chúng ta sẽ sử dụng printfhàm để làm tròn đến 4 chữ số thập phân. Lưu ý rằng các 3.14159...vòng bây giờ để 3.1416. Vì chúng tôi đang làm tròn, chúng tôi không còn cần phải sử dụng scale=10để cắt ngắn đến 10 chữ số thập phân, vì vậy chúng tôi sẽ chỉ xóa phần đó. Đây là giải pháp cuối cùng:

   pi=$(printf %.4f $(echo "4*a(1)" | bc -l)); echo $pi
   3.1416

Đây là một ứng dụng thực sự tuyệt vời và bản demo của các kỹ thuật trên: đo lường và in thời gian chạy.

Lưu ý rằng dt_minđược làm tròn từ 0.01666666666...đến 0.017:

start=$SECONDS; sleep 1; end=$SECONDS; dt_sec=$(( end - start )); dt_min=$(printf %.3f $(echo "$dt_sec/60" | bc -l)); echo "dt_sec = $dt_sec; dt_min = $dt_min"
dt_sec = 1; dt_min = 0.017

Liên quan:

• /unix/52313/how-to-get-execut-time-of-a-script-effectively/547849#547849
• Ba dấu ngoặc góc trái (`<<<`) có nghĩa là gì trong bash?
• /unix/80362/what-does-mean/80368#80368
• https://askubfox.com/questions/179898/how-to-round-decimals-USE-bc-in-bash/574474#574474

Sử dụng calc. Đây là ví dụ dễ tìm thấy nhất:

calc 1 + 1

 2

calc 1/10

 0.1

Đối với những người cố gắng tính tỷ lệ phần trăm với câu trả lời được chấp nhận, nhưng đang mất độ chính xác:

Nếu bạn chạy này:

echo "scale=2; (100/180) * 180" | bc

Bạn 99.00chỉ nhận được , đó là mất độ chính xác.

Nếu bạn chạy nó theo cách này:

echo "result = (100/180) * 180; scale=2; result / 1" | bc -l

Bây giờ bạn có được 99.99.

Bởi vì bạn chỉ mở rộng quy mô tại thời điểm in.

Tham khảo tại đây

** Toán học dấu phẩy động an toàn trong bash / shell **

Lưu ý: Trọng tâm của câu trả lời này là cung cấp ý tưởng cho giải pháp tiêm an toàn để thực hiện toán học trong bash (hoặc các vỏ khác).Tất nhiên, có thể được sử dụng tương tự, với điều chỉnh nhỏ để thực hiện xử lý chuỗi nâng cao, v.v.

Hầu hết các giải pháp đã được trình bày, xây dựng scriptlet nhỏ một cách nhanh chóng, sử dụng dữ liệu ngoài (biến, tệp, dòng lệnh, biến môi trường). Đầu vào bên ngoài có thể được sử dụng để tiêm mã độc vào động cơ, nhiều trong số chúng

Dưới đây là so sánh về việc sử dụng các ngôn ngữ khác nhau để thực hiện phép tính toán cơ bản, trong đó kết quả là dấu phẩy động. Nó tính toán A + B * 0,1 (dưới dạng dấu phẩy động).

Tất cả các giải pháp đều cố gắng tránh tạo các tập lệnh động, cực kỳ khó bảo trì, thay vào đó chúng sử dụng chương trình tĩnh và truyền tham số vào biến được chỉ định. Họ sẽ xử lý các tham số một cách an toàn với các ký tự đặc biệt - giảm khả năng tiêm mã. Ngoại lệ là 'BC' không cung cấp cơ sở đầu vào / đầu ra

Ngoại lệ là 'bc', không cung cấp bất kỳ đầu vào / đầu ra nào, tất cả dữ liệu đến thông qua các chương trình trong stdin và tất cả đầu ra đều đi vào thiết bị xuất chuẩn. Tất cả các tính toán đang thực hiện trong một hộp cát, không cho phép tác dụng phụ (mở tệp, v.v.). Về lý thuyết, tiêm an toàn theo thiết kế!

A=5.2
B=4.3

# Awk: Map variable into awk
# Exit 0 (or just exit) for success, non-zero for error.
#
awk -v A="$A" -v B="$B" 'BEGIN { print A + B * 0.1 ; exit 0}'

# Perl
perl -e '($A,$B) = @ARGV ; print $A + $B * 0.1' "$A" "$B"

# Python 2
python -c 'import sys ; a = float(sys.argv[1]) ; b = float(sys.argv[2]) ; print a+b*0.1' "$A" "$B"

# Python 3
python3 -c 'import sys ; a = float(sys.argv[1]) ; b = float(sys.argv[2]) ; print(a+b*0.1)' "$A" "$B"

# BC
bc <<< "scale=1 ; $A + $B * 0.1"

đây là lệnh awk: -F = dấu phân cách trường == +

echo "2.1+3.1" |  awk -F "+" '{print ($1+$2)}'