Comment arrondir les nombres décimaux en utilisant bc dans bash?

Un exemple rapide de ce que je veux utiliser les scripts bash:

#!/bin/bash
echo "Insert the price you want to calculate:"
read float
echo "This is the price without taxes:"
echo "scale=2; $float/1.18" |bc -l
read -p "Press any key to continue..."
bash scriptname.sh

En supposant que le prix est: 48.86 La réponse sera: 41.406779661 (41.40 en fait parce que je l'utilise scale=2;)

Ma question est la suivante: comment arrondir la deuxième décimale pour afficher la réponse de cette manière ?: 41.41

Une fonction bash round:

round()
{
echo $(printf %.$2f $(echo "scale=$2;(((10^$2)*$1)+0.5)/(10^$2)" | bc))
};

Utilisé dans votre exemple de code:

#!/bin/bash
# the function "round()" was taken from 
# http://stempell.com/2009/08/rechnen-in-bash/

# the round function:
round()
{
echo $(printf %.$2f $(echo "scale=$2;(((10^$2)*$1)+0.5)/(10^$2)" | bc))
};

echo "Insert the price you want to calculate:"
read float
echo "This is the price without taxes:"
#echo "scale=2; $float/1.18" |bc -l
echo $(round $float/1.18 2);
read -p "Press any key to continue..."

Bonne chance: o)

La solution la plus simple:

printf %.2f $(echo "$float/1.18" | bc -l)

Bash / awk arrondi:

echo "23.49" | awk '{printf("%d\n",$1 + 0.5)}'  

Si vous avez du python, vous pouvez utiliser quelque chose comme ceci:

echo "4.678923" | python -c "print round(float(raw_input()))"

Voici une solution purement bc. Règles d'arrondi: à +/- 0,5, arrondir à zéro.

Mettez la balance que vous cherchez dans $ result_scale; votre calcul devrait être où $ MATH est situé dans la liste de commande bc:

bc <<MATH
h=0
scale=0

/* the magnitude of the result scale */
t=(10 ^ $result_scale)

/* work with an extra digit */
scale=$result_scale + 1

/* your math into var: m */
m=($MATH)

/* rounding and output */
if (m < 0) h=-0.5
if (m > 0) h=0.5

a=(m * t + h)

scale=$result_scale
a / t
MATH

Je sais que c'est une vieille question, mais j'ai une solution pure 'bc' sans 'if' ou branches:

#!/bin/sh
bcr()
{
    echo "scale=$2+1;t=$1;scale-=1;(t*10^scale+((t>0)-(t<0))/2)/10^scale" | bc -l
}

Utilisez-le comme bcr '2/3' 5ou bcr '0.666666' 2-> (expression suivie d'une échelle)

C'est possible parce qu'en bc (comme C / C ++), il est permis de mélanger des expressions logiques dans vos calculs. L'expression ((t>0)-(t<0))/2)sera évaluée à +/- 0.5 en fonction du signe de 't' et utilisera donc la bonne valeur pour l'arrondi.

#!/bin/bash
# - loosely based on the function "round()", taken from 
# http://stempell.com/2009/08/rechnen-in-bash/

# - inspired by user85321 @ askubuntu.com (original author)
#   and Aquarius Power

# the round function (alternate approach):

round2()
{
    v=$1
    vorig=$v
    # if negative, negate value ...
    (( $(bc <<<"$v < 0") == 1 )) && v=$(bc <<<"$v * -1")
    r=$(bc <<<"scale=$3;(((10^$3)*$v/$2)+0.5)/(10^$3)")

    # ... however, since value was only negated to get correct rounding, we 
    # have to add the minus sign again for the resulting value ...

    (( $(bc <<< "$vorig < 0") == 1 )) && r=$(bc <<< "$r * -1")
    env printf %.$3f $r
};

echo "Insert the price you want to calculate:"
read float
echo "This is the price without taxes:"
round2 $float 1.18 2
echo && read -p "Press any key to continue..."

C'est en fait simple: il n'est pas nécessaire d'ajouter explicitement une variante "-0.5" codée en dur pour les nombres négatifs. Mathématiquement parlant, nous allons simplement calculer la valeur absolue de l'argument et ajouter toujours 0,5 comme nous le ferions normalement. Mais comme nous n’avons (malheureusement) pas de abs()fonction intégrée à notre disposition (sauf si nous en codons une), nous allons simplement nier l’argument s’il est négatif.

En outre, travailler avec le quotient en tant que paramètre s'est avéré très fastidieux (car pour ma solution, je dois pouvoir accéder au dividende et au diviseur séparément). C'est pourquoi mon script a un troisième paramètre supplémentaire.

Je cherche toujours une bcréponse pure à la méthode pour arrondir une seule valeur dans une fonction, mais voici une bashréponse pure :

#!/bin/bash

echo "Insert the price you want to calculate:"
read float
echo "This is the price without taxes:"

embiggen() {
  local int precision fraction=""
  if [ "$1" != "${1#*.}" ]; then  # there is a decimal point
    fraction="${1#*.}"       # just the digits after the dot
  fi
  int="${1%.*}"              # the float as a truncated integer
  precision="${#fraction}"   # the number of fractional digits
  echo $(( 10**10 * $int$fraction / 10**$precision ))
}

# round down if negative
if [ "$float" != "${float#-}" ]
  then round="-5000000000"
  else round="5000000000"
fi

# calculate rounded answer (sans decimal point)
answer=$(( ( `embiggen $float` * 100 + $round ) / `embiggen 1.18` ))

int=${answer%??}  # the answer as a truncated integer

echo $int.${answer#$int}  # reassemble with correct precision

read -p "Press any key to continue..."

En gros, cela extrait soigneusement les décimales, multiplie tout par 100 milliards (10¹⁰, 10**10en bash), ajuste de précision et de l' arrondissement, effectue la division réelle, divise Retour à la grandeur appropriée, et réinsère alors la décimale.

Pas à pas:

La embiggen()fonction affecte la forme entière tronquée de son argument à $intet enregistre les nombres après le point dans $fraction. Le nombre de chiffres fractionnaires est noté dans $precision. Le calcul multiplie 10¹⁰ par la concaténation de $intet $fractionpuis ajuste cela pour correspondre à la précision ( embiggen 48.86devient par exemple 10¹⁰ × 4886/100 et renvoie 488600000000ce qui est 488,600,000,000).

Nous voulons une précision finale de centièmes. Nous multiplions donc le premier nombre par 100, en ajoutons 5 aux fins de l'arrondi, puis nous divisons le deuxième nombre. Cette cession de $answernous laisse cent fois la réponse finale.

Nous devons maintenant ajouter le point décimal. Nous attribuons une nouvelle $intvaleur pour $answerexclure ses deux derniers chiffres, puis echoun point et l’ $answerexclusion de la $intvaleur déjà prise en charge. (Peu importe le bug de mise en évidence de la syntaxe qui le fait apparaître comme un commentaire)

(Bashism: l’exponentiation n’est pas POSIX, c’est donc un penchant. Une solution POSIX pure nécessiterait des boucles pour ajouter des zéros plutôt que d’utiliser des puissances de dix. En outre, "embiggen" est un mot parfaitement cromulant.)

L'une des principales raisons pour lesquelles j'utilise zshle shell est qu'il prend en charge les mathématiques en virgule flottante. La solution à cette question est assez simple dans zsh:

printf %.2f $((float/1.18))

(J'aimerais beaucoup que quelqu'un ajoute un commentaire à cette réponse en essayant d'activer l'arithmétique en virgule flottante bash, mais je suis à peu près sûr qu'une telle fonctionnalité n'existe pas encore.)

si vous avez le résultat, considérez par exemple 2.3747888

Tout ce que tu dois faire est:

d=$(echo "(2.3747888+0.5)/1" | bc); echo $d

ceci arrondit correctement le nombre, par exemple:

(2.49999 + 0.5)/1 = 2.99999 

les décimales sont supprimées par bcet donc il arrondit à 2 comme il se doit

Je devais calculer la durée totale d'une collection de fichiers audio.

Donc je devais:

A. obtenir la durée de chaque fichier ( non montré )

B. additionnez toutes les durées (elles étaient chacune en NNN.NNNNNN(fp) secondes)

C. séparez les heures, les minutes, les secondes, les sous-secondes.

D. sort une chaîne de HR: MIN: SEC: FRAMES, où frame = 1/75 sec.

(Les cadres proviennent du code SMPTE utilisé dans les studios.)

A: utiliser ffprobeet analyser la ligne de durée dans un nombre fp (non montré)

B:

 # add them up as a series of strings separated by "+" and send it to bc

arr=( "${total[@]}" )  # copy array

# IFS is "Internal Field Separator"
# the * in arr[*] means "all of arr separated by IFS" 
# must have been made for this
IFS='+' sum=$(echo "scale=3; ${arr[*]} "| bc -l)# (-l= libmath for fp)
echo $sum 

C:

# subtract each amount of time from tt and store it    
tt=$sum   # tt is a running var (fp)


hrs=$(echo "$tt / 3600" | bc)

tt=$(echo "$tt - ( $hrs * 3600 )" | bc )

min=$(echo "$tt / 60" | bc )

tt=$(echo "$tt - ($min *60)" | bc )

sec=$(echo "$tt/1" | bc )

tt=$(echo "$tt - $sec" | bc )

frames=$(echo "$tt * 75"  | bc ) # 75 frames /sec 
frames=$(echo "$frames/1" | bc ) # truncate to whole #

RÉ:

#convert to proper format with printf (bash builtin)        
hrs=$(printf "%02d\n" $hrs)  # format 1 -> 01 

min=$(printf "%02d\n" $min)

sec=$(printf "%02d\n" $sec)

frames=$(printf "%02d\n" $frames)

timecode="$hrs:$min:$sec:$frames"

# timecode "01:13:34:54"

Voici une version abrégée de votre script, corrigée pour fournir le résultat souhaité:

#!/bin/bash
float=48.86
echo "You asked for $float; This is the price without taxes:"
echo "scale=3; price=$float/1.18 +.005; scale=2; price/1 " | bc

Notez que arrondir au nombre entier le plus proche équivaut à ajouter 0,5 et prendre la parole, ou arrondir à la baisse (pour les nombres positifs).

En outre, le facteur d'échelle est appliqué au moment de l'opération; alors (ce sont des bccommandes, vous pouvez les coller dans votre terminal):

float=48.86; rate=1.18; 
scale=2; p2=float/rate
scale=3; p3=float/rate
scale=4; p4=float/rate
print "Compare:  ",p2, " v ", p3, " v ", p4
Compare:  41.40 v 41.406 v 41.4067

# however, scale does not affect an entered value (nor addition)
scale=0
a=.005
9/10
0
9/10+a
.005

# let's try rounding
scale=2
p2+a
41.405
p3+a
41.411
(p2+a)/1
41.40
(p3+a)/1
41.41

Pure BC implémentation à la demande

define ceil(x) { auto os,xx;x=-x;os=scale;scale=0 xx=x/1;if(xx>x).=xx-- scale=os;return(-xx) }

si vous mettez cela dans un fichier appelé functions.bc, alors vous pouvez arrondir avec

echo 'ceil(3.1415)' | bc functions.bc

Code pour l'implémentation bc trouvé sur http://phodd.net/gnu-bc/code/funcs.bc

bc() {
        while :
        do
                while IFS='$\n' read i
                do
                        /usr/bin/bc <<< "scale=2; $i" | sed 's/^\./0&/'
                done
        done
}

Vous pouvez utiliser awk, aucun tuyau nécessaire:

$> PRICE=48.86
$> awk -vprice=$PRICE "BEGIN{printf(\"%.2f\n\",price/1.18+0.005)}"
41.41

Définissez le prix au préalable avec la variable d'environnement PRICE=<val>.

• Ensuite, appelez awk - $PRICEentrera dans awk en tant que variable awk price.

• Il est ensuite arrondi au 100ème le plus proche avec +.005.

• L'option de formatage printf %.2flimite l'échelle à deux décimales.

Si vous devez faire cela beaucoup de cette façon, c'est beaucoup plus efficace que la réponse choisie:

time for a in {1..1000}; do echo $(round 48.86/1.18 2) > /dev/random; done
real    0m8.945s
user    0m6.067s
sys 0m4.277s

time for a in {1..1000}; do awk -vprice=$PRICE "BEGIN{printf(\"%.2f\n\",price/1.18+0.005)}">/dev/random; done
real    0m2.628s
user    0m1.462s
sys 0m1.275s