J'essaye de comparer deux nombres à virgule flottante dans un script bash. Je dois des variables, par exemple

let num1=3.17648e-22
let num2=1.5

Maintenant, je veux juste faire une simple comparaison de ces deux nombres:

st=`echo "$num1 < $num2" | bc`
if [ $st -eq 1]; then
  echo -e "$num1 < $num2"
else
  echo -e "$num1 >= $num2"
fi

Malheureusement, j'ai quelques problèmes avec le bon traitement du num1 qui peut être du "e-format". :(

Toute aide, conseils sont les bienvenus!

Plus commodément

Cela peut être fait plus facilement en utilisant le contexte numérique de Bash:

if (( $(echo "$num1 > $num2" |bc -l) )); then
  …
fi

Explication

Le fait de passer par la commande de base de la calculatrice bcrenvoie 1 ou 0.

L'option -léquivaut à --mathlib; il charge la bibliothèque mathématique standard.

Mettre l'expression entière entre doubles parenthèses (( ))traduira ces valeurs respectivement en vrai ou en faux.

Veuillez vous assurer que le bcpackage de base de la calculatrice est installé.

Cela fonctionne également pour les flotteurs au format scientifique, à condition qu'une lettre majuscule Esoit utilisée, par exemplenum1=3.44E6

bash ne gère que les nombres entiers, mais vous pouvez utiliser la bccommande comme suit:

$ num1=3.17648E-22
$ num2=1.5
$ echo $num1'>'$num2 | bc -l
0
$ echo $num2'>'$num1 | bc -l
1

Notez que le signe de l'exposant doit être en majuscule

Il est préférable de l'utiliser awkpour les mathématiques non entières. Vous pouvez utiliser cette fonction utilitaire bash:

numCompare() {
   awk -v n1="$1" -v n2="$2" 'BEGIN {printf "%s " (n1<n2?"<":">=") " %s\n", n1, n2}'
}

Et appelez-le comme:

numCompare 5.65 3.14e-22
5.65 >= 3.14e-22

numCompare 5.65e-23 3.14e-22
5.65e-23 < 3.14e-22

numCompare 3.145678 3.145679
3.145678 < 3.145679

Solution pure bash pour comparer des flottants sans notation exponentielle, zéros de début ou de fin:

if [ ${FOO%.*} -eq ${BAR%.*} ] && [ ${FOO#*.} \> ${BAR#*.} ] || [ ${FOO%.*} -gt ${BAR%.*} ]; then
  echo "${FOO} > ${BAR}";
else
  echo "${FOO} <= ${BAR}";
fi

L'ordre des opérateurs logiques est important . Les parties entières sont comparées sous forme de nombres et les parties fractionnaires sont intentionnellement comparées sous forme de chaînes. Les variables sont divisées en parties entières et fractionnaires à l'aide de cette méthode .

Ne comparera pas les flottants avec des entiers (sans point).

vous pouvez utiliser awk combiné avec une condition bash if, awk affichera 1 ou 0 et ceux-ci seront interprétés par la clause if avec vrai ou faux .

if awk 'BEGIN {print ('$d1' >= '$d2')}'; then
    echo "yes"
else 
    echo "no"
fi

méfiez-vous lorsque vous comparez des nombres qui sont des versions de package, comme vérifier si grep 2.20 est supérieur à la version 2.6:

$ awk 'BEGIN { print (2.20 >= 2.6) ? "YES" : "NO" }'
NO

$ awk 'BEGIN { print (2.2 >= 2.6) ? "YES" : "NO" }'
NO

$ awk 'BEGIN { print (2.60 == 2.6) ? "YES" : "NO" }'
YES

J'ai résolu ce problème avec une telle fonction shell / awk:

# get version of GNU tool
toolversion() {
    local prog="$1" operator="$2" value="$3" version

    version=$($prog --version | awk '{print $NF; exit}')

    awk -vv1="$version" -vv2="$value" 'BEGIN {
        split(v1, a, /\./); split(v2, b, /\./);
        if (a[1] == b[1]) {
            exit (a[2] '$operator' b[2]) ? 0 : 1
        }
        else {
            exit (a[1] '$operator' b[1]) ? 0 : 1
        }
    }'
}

if toolversion grep '>=' 2.6; then
   # do something awesome
fi

Bien sûr, si vous n'avez pas vraiment besoin d'arithmétique à virgule flottante, juste de l'arithmétique sur, par exemple, des valeurs en dollars où il y a toujours exactement deux chiffres décimaux, vous pouvez simplement supprimer le point (multipliant effectivement par 100) et comparer les entiers résultants.

if [[ $((10#${num1/.})) < $((10#${num2/.})) ]]; then
    ...

Cela nécessite évidemment que vous soyez sûr que les deux valeurs ont le même nombre de décimales.

J'ai utilisé les réponses d'ici et les ai mises dans une fonction, vous pouvez l'utiliser comme ceci:

is_first_floating_number_bigger 1.5 1.2
result="${__FUNCTION_RETURN}"

Une fois appelé, echo $resultsera 1dans ce cas, sinon 0.

La fonction:

is_first_floating_number_bigger () {
    number1="$1"
    number2="$2"

    [ ${number1%.*} -eq ${number2%.*} ] && [ ${number1#*.} \> ${number2#*.} ] || [ ${number1%.*} -gt ${number2%.*} ];
    result=$?
    if [ "$result" -eq 0 ]; then result=1; else result=0; fi

    __FUNCTION_RETURN="${result}"
}

Ou une version avec sortie de débogage:

is_first_floating_number_bigger () {
    number1="$1"
    number2="$2"

    echo "... is_first_floating_number_bigger: comparing ${number1} with ${number2} (to check if the first one is bigger)"

    [ ${number1%.*} -eq ${number2%.*} ] && [ ${number1#*.} \> ${number2#*.} ] || [ ${number1%.*} -gt ${number2%.*} ];
    result=$?
    if [ "$result" -eq 0 ]; then result=1; else result=0; fi

    echo "... is_first_floating_number_bigger: result is: ${result}"

    if [ "$result" -eq 0 ]; then
        echo "... is_first_floating_number_bigger: ${number1} is not bigger than ${number2}"
    else
        echo "... is_first_floating_number_bigger: ${number1} is bigger than ${number2}"
    fi

    __FUNCTION_RETURN="${result}"
}

Enregistrez simplement la fonction dans un .shfichier séparé et incluez-la comme ceci:

. /path/to/the/new-file.sh

Je postais ceci en réponse à https://stackoverflow.com/a/56415379/1745001 quand il a été fermé en tant que dup de cette question, alors le voici comme cela s'applique ici aussi:

Pour plus de simplicité et de clarté, utilisez simplement awk pour les calculs car c'est un outil UNIX standard et donc tout aussi susceptible d'être présent que bc et beaucoup plus facile à utiliser syntaxiquement.

Pour cette question:

$ cat tst.sh
#!/bin/bash

num1=3.17648e-22
num2=1.5

awk -v num1="$num1" -v num2="$num2" '
BEGIN {
    print "num1", (num1 < num2 ? "<" : ">="), "num2"
}
'

$ ./tst.sh
num1 < num2

et pour cette autre question qui a été fermée comme une dupe de celle-ci:

$ cat tst.sh
#!/bin/bash

read -p "Operator: " operator
read -p "First number: " ch1
read -p "Second number: " ch2

awk -v ch1="$ch1" -v ch2="$ch2" -v op="$operator" '
BEGIN {
    if ( ( op == "/" ) && ( ch2 == 0 ) ) {
        print "Nope..."
    }
    else {
        print ch1 '"$operator"' ch2
    }
}
'

$ ./tst.sh
Operator: /
First number: 4.5
Second number: 2
2.25

$ ./tst.sh
Operator: /
First number: 4.5
Second number: 0
Nope...

awket des outils comme celui-ci (je vous regarde fixement sed...) devraient être relégués à la poubelle des vieux projets, avec du code que tout le monde a trop peur de toucher puisqu'il a été écrit dans un langage sans lecture.

Ou vous êtes le projet relativement rare qui doit donner la priorité à l'optimisation de l'utilisation du processeur par rapport à l'optimisation de la maintenance du code ... auquel cas, continuez.

Sinon, pourquoi ne pas utiliser à la place quelque chose de lisible et explicite, comme python? Vos collègues codeurs et votre futur moi vous remercieront. Vous pouvez utiliser en pythonligne avec bash comme tous les autres.

num1=3.17648E-22
num2=1.5
if python -c "exit(0 if $num1 < $num2 else 1)"; then
    echo "yes, $num1 < $num2"
else
    echo "no, $num1 >= $num2"
fi

Ce script peut aider lorsque je vérifie si la grailsversion installée est supérieure au minimum requis. J'espère que ça aide.

#!/bin/bash                                                                                         

min=1.4                                                                                             
current=`echo $(grails --version | head -n 2 | awk '{print $NF}' | cut -c 1-3)`                         

if [ 1 -eq `echo "${current} < ${min}" | bc` ]                                                          
then                                                                                                
    echo "yo, you have older version of grails."                                                   
else                                                                                                                                                                                                                       
    echo "Hurray, you have the latest version" 
fi

num1=0.555
num2=2.555


if [ `echo "$num1>$num2"|bc` -eq 1 ]; then
       echo "$num1 is greater then $num2"
else
       echo "$num2 is greater then $num1"
fi

veuillez vérifier le code édité ci-dessous: -

#!/bin/bash

export num1=(3.17648*e-22)
export num2=1.5

st=$((`echo "$num1 < $num2"| bc`))
if [ $st -eq 1 ]
  then
    echo -e "$num1 < $num2"
  else
    echo -e "$num1 >= $num2"
fi

cela fonctionne bien.

Une solution prenant en charge toutes les notations possibles, y compris la notation scientifique avec des exposants majuscules et minuscules (par exemple, 12.00e4):

if (( $(bc -l <<< "${value1/e/E} < ${value2/e/E}") ))
then
    echo "$value1 is below $value2"
fi 

Utilisez korn shell, dans bash, vous devrez peut-être comparer la partie décimale séparément

#!/bin/ksh
X=0.2
Y=0.2
echo $X
echo $Y

if [[ $X -lt $Y ]]
then
     echo "X is less than Y"
elif [[ $X -gt $Y ]]
then
     echo "X is greater than Y"
elif [[ $X -eq $Y ]]
then
     echo "X is equal to Y"
fi

En utilisant bashj ( https://sourceforge.net/projects/bashj/ ), un mutant bash avec support java, il vous suffit d'écrire (et c'est facile à lire):

#!/usr/bin/bashj

#!java
static int doubleCompare(double a,double b) {return((a>b) ? 1 : (a<b) ? -1 : 0);}

#!bashj
num1=3.17648e-22
num2=1.5
comp=j.doubleCompare($num1,$num2)
if [ $comp == 0 ] ; then echo "Equal" ; fi
if [ $comp == 1 ] ; then echo "$num1 > $num2" ; fi
if [ $comp == -1 ] ; then echo "$num2 > $num1" ; fi

Bien sûr, l'hybridation bashj bash / java offre bien plus ...

Que dis-tu de ça? = D

VAL_TO_CHECK="1.00001"
if [ $(awk '{printf($1 >= $2) ? 1 : 0}' <<<" $VAL_TO_CHECK 1 ") -eq 1 ] ; then
    echo "$VAL_TO_CHECK >= 1"
else
    echo "$VAL_TO_CHECK < 1"
fi