Я пытаюсь разделить две ширины изображения в скрипте Bash, но Bash дает мне 0 в результате:

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

Я изучил руководство по Bash и знаю, что должен использовать bcво всех примерах в Интернете, которые они используют bc. Вecho Я пытался поставить такую же вещь в моей , SCALEно это не сработало.

Вот пример, который я нашел в уроках:

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

Как я могу получить Bash, чтобы дать мне как поплавок 0.5?

Ты не можешь bash делает только целые числа; Вы должны делегировать такие инструменты, как bc.

ты можешь сделать это:

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

ОБНОВЛЕНИЕ 20130926 : вы можете использовать:

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

удар

Как отмечалось другими, bashне поддерживает арифметику с плавающей запятой, хотя вы можете подделать ее с помощью некоторого фиксированного десятичного трюка, например, с двумя десятичными знаками:

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

Вывод:

.33

Смотрите ответ Нильфреда для аналогичного, но более краткого подхода.

альтернативы

Помимо упомянутых bcи awkальтернатив есть также следующее:

CLISP

clisp -x '(/ 1.0 3)'

с убранным выходом:

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

или через стандартный ввод:

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

Округ Колумбия

echo 2k 1 3 /p | dc

гений кли калькулятор

echo 1/3.0 | genius

Ghostscript

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

Или:

jq -n 1/3

КШ

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

Lua

lua -e 'print(1/3)'

или через стандартный ввод:

echo 'print(1/3)' | lua

максима

echo '1/3,numer;' | maxima

с убранным выходом:

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

узел

echo 1/3 | node -p

октава

echo 1/3 | octave

Perl

echo print 1/3 | perl

python2

echo print 1/3. | python2

python3

echo 'print(1/3)' | python3

р

echo 1/3 | R --no-save

с убранным выходом:

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

Рубин

echo print 1/3.0 | ruby

Wcalc

echo 1/3 | wcalc

С убранным выходом:

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

ЗШ

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

единицы

units 1/3

С компактным выходом:

units --co 1/3

Другие источники

Стефан Шазелас ответил на аналогичный вопрос в Unix.SX.

Немного улучшив ответ Марвина:

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

bc не всегда поставляется как установленный пакет.

Вы можете использовать bc по -lопции (буква L)

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

В качестве альтернативы bc вы можете использовать awk в вашем скрипте.

Например:

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

Выше "% .2f" сообщает функции printf возвращать число с плавающей запятой с двумя цифрами после запятой. Я использовал echo для передачи переменных как полей, так как awk работает с ними корректно. «$ 1» и «$ 2» относятся к первому и второму полям, вводимым в awk.

И вы можете сохранить результат как некоторую другую переменную, используя:

RESULT = `echo ...`

Это идеальное время, чтобы попробовать zsh, (почти) суперсет bash, с множеством дополнительных полезных функций, включая математику с плавающей запятой. Вот как будет выглядеть ваш пример в zsh:

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

Этот пост может вам помочь: bash - Стоит ли переходить на zsh для повседневного использования?

Что ж, до float было время, когда использовалась логика с фиксированными десятичными числами:

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

Последняя строка - bashim, если не используете bash, попробуйте этот код:

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

Обоснование кода: умножить на 100 перед делением, чтобы получить 2 десятичных знака.

Если вы нашли вариант вашего предпочтения, вы также можете включить его в функцию.

Здесь я оборачиваю некоторый bashism в функцию div:

Один лайнер:

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;}

Или многострочный:

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
}

Теперь у вас есть функция

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

и использовать его как

> div 1 2
.50

> div 273 123 5
2.21951

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

ОБНОВИТЬ Я добавил небольшой скрипт, который предоставляет вам основные операции с числами с плавающей запятой для bash:

Использование:

> 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

А вот и скрипт:

#!/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 / ;}

Это не совсем с плавающей точкой, но если вам нужно что-то, что устанавливает более одного результата в одном вызове 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

вычисляет площадь и диаметр круга, радиус которого указан в $ 1

Существуют сценарии, в которых вы не можете использовать bc, потому что он может просто не присутствовать, как в некоторых урезанных версиях busybox или встроенных системах. В любом случае ограничение внешних зависимостей - это всегда хорошая вещь, поэтому вы всегда можете добавить нули к числу, деленному на (числитель), что равносильно умножению на степень 10 (вы должны выбрать степень 10 в соответствии с точность, которая вам нужна), которая сделает вывод деления целым числом. Получив это целое число, обработайте его как строку и поместите десятичную точку (перемещая ее справа налево) число раз, равное десятичной степени, на которую вы умножили числитель. Это простой способ получения результатов с плавающей запятой, используя только целые числа.

Хотя вы не можете использовать деление с плавающей запятой в Bash, вы можете использовать деление с фиксированной запятой. Все, что вам нужно сделать, это умножить ваши целые числа на степень 10, а затем разделить целую часть и использовать операцию по модулю, чтобы получить дробную часть. Округление по мере необходимости.

#!/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))

я знаю, что он старый, но слишком заманчивый. Итак, ответ: вы не можете ... но вы можете. давайте попробуем это:

$IMG_WIDTH=1024
$IMG2_WIDTH=2048

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

Таким образом, вы получаете 2 цифры после точки, усеченные (назовите это округлением до нижнего значения, хаха) в чистом bash (не нужно запускать другие процессы). конечно, если вам нужна только одна цифра после точки, вы умножаете на 10 и делаете по модулю 10.

что это делает:

• первый $ ((...)) делает целочисленное деление;
• секунда $ ((...)) делает целочисленное деление на что-то в 100 раз больше, по существу сдвигая ваши 2 цифры влево от точки, затем (%) получая только эти 2 цифры, выполняя по модулю.

Бонусный трек : bc version x 1000 занял 1,8 секунды на моем ноутбуке, а чистый bash - 0,016 секунды.

Как сделать вычисления с плавающей точкой в ​​Bash:

Вместо использования " здесь строки » ( <<<) с bcкомандой, как это делает один из примеров с наибольшим количеством голосов , вот мой любимый bcпример с плавающей запятой прямо из EXAMPLESраздела справочныхbc страниц (см.man bc справочных страниц Справочные страницы).

Прежде чем мы начнем, знает , что уравнение для пи является: pi = 4*atan(1). a()ниже bcматематическая функция для atan().

1. Это как сохранить результат вычисления с плавающей запятой в переменную bash - в данном случае в переменнуюpi . Обратите внимание, что scale=10в этом случае количество десятичных знаков точности устанавливается равным 10. Любые десятичные цифры после этого места усекаются .

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

2. Теперь, чтобы иметь единственную строку кода, которая также печатает значение этой переменной, просто добавьте echo команду в конец в качестве последующей команды, как показано ниже. Обратите внимание на усечение в 10 десятичных разрядов, как приказано:

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

3. Наконец, давайте добавим некоторое округление. Здесь мы будем использовать printfфункцию для округления до 4 десятичных знаков. Обратите внимание, что3.14159... раундов сейчас 3.1416. Поскольку мы округляем, нам больше не нужно использовать scale=10усечение до 10 десятичных знаков, поэтому мы просто удалим эту часть. Вот конечное решение:

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

Вот еще одно действительно отличное приложение и демонстрация вышеперечисленных методов: измерение и печать во время выполнения.

Обратите внимание, что dt_min округляется от 0.01666666666...до 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

Связанный:

• /unix/52313/how-to-get-execution-time-of-a-script-effectively/547849#547849
• Что означают три левые угловые скобки (`<<<`) в bash?
• /unix/80362/what-does-mean/80368#80368
• /ubuntu/179898/how-to-round-decimals-using-bc-in-bash/574474#574474

Используйте Calc. Это самый простой пример, который я нашел:

рассчитать 1 + 1

 2

расчет 1/10

 0.1

Для тех, кто пытается рассчитать проценты с принятым ответом, но теряет точность:

Если вы запустите это:

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

Вы получаете 99.00только то, что теряет точность.

Если вы запустите это так:

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

Теперь вы получаете 99.99.

Потому что вы масштабируете только в момент печати.

Обратитесь сюда

** Безопасная для инъекций математика с плавающей запятой в bash / shell **

Примечание. Основное внимание в этом ответе уделяется идеям безопасного инъекционного решения для выполнения математических операций в bash (или других оболочках).Конечно, то же самое можно использовать с незначительной настройкой для выполнения расширенной обработки строк и т. Д.

Большинство решений, которые были представлены, конструируют небольшие скриптлеты на лету, используя внешние данные (переменные, файлы, командная строка, переменные среды). Внешний ввод может быть использован для внедрения вредоносного кода в движок, многие из них

Ниже приведено сравнение использования различных языков для выполнения базовых математических вычислений, где результат с плавающей запятой. Он рассчитывает A + B * 0,1 (как с плавающей запятой).

Все попытки решения избежать создания динамических скриптлетов, которые крайне сложно поддерживать, вместо этого они используют статическую программу и передают параметры в назначенную переменную. Они будут безопасно обрабатывать параметры с помощью специальных символов - уменьшая вероятность внедрения кода. Исключением является «BC», который не предоставляет средства ввода / вывода.

Исключением является 'bc', который не обеспечивает никакого ввода / вывода, все данные поступают через программы в stdin, а весь вывод поступает в stdout. Все расчеты выполняются в песочнице, что не допускает побочных эффектов (открытие файлов и т. Д.). Теоретически, инъекция безопасна по конструкции!

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"

вот команда awk: -F = разделитель полей == +

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