J'essaie de diviser deux largeurs d'image dans un script Bash, mais bash me donne 0le résultat:

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

J'ai étudié le guide Bash et je sais que je devrais l'utiliser bc, dans tous les exemples sur Internet qu'ils utilisent bc. Dans echoJ'ai essayé de mettre la même chose dans mon SCALEmais il ne fonctionnait pas.

Voici l'exemple que j'ai trouvé dans les tutoriels:

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

Comment puis-je demander à Bash de me donner un flotteur 0.5?

Tu ne peux pas. bash ne fait que des entiers; vous devez déléguer à un outil tel que bc.

tu peux le faire:

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

MISE À JOUR 20130926 : vous pouvez utiliser:

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

frapper

Comme indiqué par d'autres, bashne prend pas en charge l'arithmétique à virgule flottante, bien que vous puissiez la simuler avec une supercherie décimale fixe, par exemple avec deux décimales:

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

Production:

.33

Voir la réponse de Nilfred pour une approche similaire mais plus concise.

Alternatives

Outre les options mentionnées bcet awkalternatives, il existe également les suivantes:

clisp

clisp -x '(/ 1.0 3)'

avec sortie nettoyée:

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

ou via stdin:

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

dc

echo 2k 1 3 /p | dc

genius cli calculator

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

Ou:

jq -n 1/3

ksh

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

lua

lua -e 'print(1/3)'

ou via stdin:

echo 'print(1/3)' | lua

maxima

echo '1/3,numer;' | maxima

avec sortie nettoyée:

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

nœud

echo 1/3 | node -p

octave

echo 1/3 | octave

perl

echo print 1/3 | perl

python2

echo print 1/3. | python2

python3

echo 'print(1/3)' | python3

R

echo 1/3 | R --no-save

avec sortie nettoyée:

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

rubis

echo print 1/3.0 | ruby

wcalc

echo 1/3 | wcalc

Avec sortie nettoyée:

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

zsh

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

unités

units 1/3

Avec une sortie compacte:

units --co 1/3

Autres sources

Stéphane Chazelas a répondu à une question similaire sur Unix.SX.

Améliorant un peu la réponse de marvin:

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

bc ne vient pas toujours comme paquet installé.

Vous pouvez utiliser bc par l' -loption (la lettre L)

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

Comme alternative à bc, vous pouvez utiliser awk dans votre script.

Par exemple:

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

Dans ce qui précède, "% .2f" indique à la fonction printf de renvoyer un nombre à virgule flottante avec deux chiffres après la décimale. J'ai utilisé l'écho pour diriger les variables sous forme de champs car awk fonctionne correctement sur elles. "$ 1" et "$ 2" font référence aux premier et second champs entrés dans awk.

Et vous pouvez stocker le résultat comme une autre variable en utilisant:

RESULT = `echo ...`

C'est le moment idéal pour essayer zsh, un sur-ensemble (presque) bash, avec de nombreuses fonctionnalités supplémentaires, y compris les mathématiques en virgule flottante. Voici à quoi ressemblerait votre exemple dans zsh:

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

Cet article peut vous aider: bash - Vaut-il la peine de passer à zsh pour une utilisation décontractée?

Eh bien, avant float était un temps où la logique des décimales fixes était utilisée:

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

La dernière ligne est un bashim, si vous n'utilisez pas bash, essayez plutôt ce code:

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

La raison d'être du code est la suivante: multipliez par 100 avant de diviser pour obtenir 2 décimales.

Si vous avez trouvé la variante de votre préférence, vous pouvez également l'encapsuler dans une fonction.

Ici, j'emballe un bashisme dans une fonction div:

Bon mot:

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

Ou multi-ligne:

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
}

Vous avez maintenant la fonction

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

et l'utiliser comme

> div 1 2
.50

> div 273 123 5
2.21951

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

MISE À JOUR J'ai ajouté un petit script qui vous fournit les opérations de base avec des nombres à virgule flottante pour bash:

Usage:

> 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

Et voici le script:

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

Ce n'est pas vraiment une virgule flottante, mais si vous voulez quelque chose qui définit plus d'un résultat en une seule invocation de 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

calcule l'aire et le diamètre d'un cercle dont le rayon est donné en $ 1

Il existe des scénarios dans lesquels vous ne pouvez pas utiliser bc car il pourrait tout simplement ne pas être présent, comme dans certaines versions réduites de busybox ou de systèmes intégrés. Dans tous les cas, limiter les dépendances externes est toujours une bonne chose à faire, vous pouvez donc toujours ajouter des zéros au nombre divisé par (numérateur), ce qui revient à multiplier par une puissance de 10 (vous devez choisir une puissance de 10 selon la précision dont vous avez besoin), cela fera de la division un nombre entier. Une fois que vous avez cet entier, traitez-le comme une chaîne et positionnez le point décimal (en le déplaçant de droite à gauche) un nombre de fois égal à la puissance de dix, vous avez multiplié le numérateur par. Il s'agit d'un moyen simple d'obtenir des résultats flottants en utilisant uniquement des nombres entiers.

Bien que vous ne puissiez pas utiliser la division en virgule flottante dans Bash, vous pouvez utiliser la division en virgule fixe. Tout ce que vous devez faire est de multiplier vos entiers par une puissance de 10, puis de diviser la partie entière et d'utiliser une opération modulo pour obtenir la partie fractionnaire. Arrondi au besoin.

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

je sais que c'est vieux, mais trop tentant. donc, la réponse est: vous ne pouvez pas ... mais vous pouvez en quelque sorte. Essayons ça:

$IMG_WIDTH=1024
$IMG2_WIDTH=2048

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

comme ça, vous obtenez 2 chiffres après le point, tronqués (appelez-les arrondis au bas, haha) en bash pur (pas besoin de lancer d'autres processus). bien sûr, si vous n'avez besoin que d'un chiffre après le point, vous multipliez par 10 et faites modulo 10.

ce que cela fait:

• premier $ ((...)) fait une division entière;
• second $ ((...)) fait une division entière sur quelque chose de 100 fois plus grand, déplaçant essentiellement vos 2 chiffres vers la gauche du point, puis (%) vous obtenant seulement ces 2 chiffres en faisant modulo.

piste bonus : la version bc x 1000 a pris 1,8 secondes sur mon ordinateur portable, tandis que la version bash pure a pris 0,016 secondes.

Comment faire des calculs à virgule flottante dans bash:

Au lieu d'utiliser " ici des chaînes " ( <<<) avec la bccommande, comme le fait l'un des exemples les plus appréciés , voici mon bcexemple de virgule flottante préféré , directement dans la EXAMPLESsection des bcpages de manuel (voir man bcles pages de manuel).

Avant de commencer, sachez que pour une équation pi est: pi = 4*atan(1). a()ci-dessous est la bcfonction mathématique pour atan().

1. Voici comment stocker le résultat d'un calcul à virgule flottante dans une variable bash - dans ce cas dans une variable appeléepi . Notez que scale=10définit le nombre de chiffres décimaux de précision à 10 dans ce cas. Tous les chiffres décimaux après cet endroit sont tronqués .

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

2. Maintenant, pour avoir une seule ligne de code qui imprime également la valeur de cette variable, ajoutez simplement la echocommande à la fin en tant que commande de suivi, comme suit. Notez la troncature à 10 décimales, comme commandé:

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

3. Enfin, jetons quelques arrondis. Ici, nous utiliserons la printffonction pour arrondir à 4 décimales. Notez que les 3.14159...tours maintenant 3.1416. Puisque nous arrondissons, nous n'avons plus besoin d'utiliser scale=10pour tronquer à 10 décimales, nous allons donc simplement supprimer cette partie. Voici la solution finale:

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

Voici une autre très bonne application et démonstration des techniques ci-dessus: mesurer et imprimer le temps d'exécution.

Notez que la valeur dt_minest arrondie de 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

En relation:

• /unix/52313/how-to-get-execution-time-of-a-script-effectively/547849#547849
• Que signifient trois parenthèses angulaires gauches (`<<<`) dans bash?
• /unix/80362/what-does-mean/80368#80368
• /ubuntu/179898/how-to-round-decimals-using-bc-in-bash/574474#574474

Utilisez calc. C'est l'exemple le plus simple que j'ai trouvé:

calc 1 + 1

 2

calc 1/10

 0.1

Pour ceux qui essaient de calculer des pourcentages avec la réponse acceptée, mais qui perdent en précision:

Si vous exécutez ceci:

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

Vous obtenez 99.00seulement, ce qui perd de la précision.

Si vous l'exécutez de cette façon:

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

Maintenant vous obtenez 99.99.

Parce que vous ne mettez à l'échelle qu'au moment de l'impression.

Se référer ici

** Mathématiques à virgule flottante sécurisées pour les injections dans bash / shell **

Remarque: L'objectif de cette réponse est de fournir des idées pour une solution sécurisée par injection pour effectuer des mathématiques dans bash (ou d'autres shells). Bien sûr, la même chose peut être utilisée, avec des ajustements mineurs pour effectuer un traitement avancé des chaînes, etc.

La plupart des solutions présentées ont été construites à la volée, à l'aide de données externes (variables, fichiers, ligne de commande, variables d'environnement). L'entrée externe peut être utilisée pour injecter du code malveillant dans le moteur, beaucoup d'entre eux

Ci-dessous est une comparaison sur l'utilisation des différents langages pour effectuer des calculs mathématiques de base, où le résultat en virgule flottante. Il calcule A + B * 0,1 (en virgule flottante).

Toutes les solutions tentent d'éviter de créer des scriptlets dynamiques, qui sont extrêmement difficiles à maintenir. À la place, ils utilisent un programme statique et transmettent les paramètres à la variable désignée. Ils géreront en toute sécurité les paramètres avec des caractères spéciaux - réduisant ainsi la possibilité d'injection de code. L'exception est «BC» qui ne fournit pas de fonctionnalité d'entrée / sortie

L'exception est 'bc', qui ne fournit aucune entrée / sortie, toutes les données proviennent de programmes dans stdin, et toutes les sorties vont à stdout. Tous les calculs s'exécutent dans un sandbox, ce qui ne permet pas d'effet secondaire (ouverture de fichiers, etc.). En théorie, l'injection est sûre par conception!

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"

voici la commande awk: -F = séparateur de champ == +

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