Estoy tratando de comparar dos números de coma flotante dentro de un script bash. Tengo que variables, por ejemplo

let num1=3.17648e-22
let num2=1.5

Ahora, solo quiero hacer una comparación simple de estos dos números:

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

Desafortunadamente, tengo algunos problemas con el tratamiento correcto de num1 que puede ser del "formato e". :(

Cualquier ayuda, sugerencias son bienvenidas!

Más convenientemente

Esto se puede hacer más convenientemente usando el contexto numérico de Bash:

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

Explicación

La canalización a través del comando de la calculadora básica bcdevuelve 1 o 0.

La opción -les equivalente a --mathlib; carga la biblioteca matemática estándar.

El encerrar la expresión completa entre paréntesis dobles (( ))traducirá estos valores a verdadero o falso respectivamente.

Por favor, asegúrese de que bcesté instalado el paquete básico de la calculadora.

Esto también funciona para carrozas en formato científico, siempre que Ese utilice una letra mayúscula , por ejemplonum1=3.44E6

bash maneja solo matemáticas enteras, pero puede usar el bccomando de la siguiente manera:

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

Tenga en cuenta que el signo exponente debe estar en mayúscula

Es mejor usarlo awkpara matemáticas no enteras. Puede usar esta función de utilidad bash:

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

Y llámalo como:

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

Solución de bash pura para comparar flotadores sin notación exponencial, ceros iniciales o finales:

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

El orden de los operadores lógicos es importante . Las partes enteras se comparan como números y las partes fraccionarias se comparan intencionalmente como cadenas. Las variables se dividen en partes enteras y fraccionarias utilizando este método .

No comparará flotantes con enteros (sin punto).

puede usar awk combinado con una condición bash if, awk imprimirá 1 o 0 y estos se interpretarán mediante la cláusula if con verdadero o falso .

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

tenga cuidado al comparar números que son versiones de paquetes, como verificar si grep 2.20 es mayor que la versión 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

Resolví tal problema con dicha función 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

Por supuesto, si no necesita realmente la aritmética de coma flotante, solo la aritmética en, por ejemplo, valores de dólar donde siempre hay exactamente dos dígitos decimales, puede simplemente soltar el punto (multiplicando efectivamente por 100) y comparar los enteros resultantes.

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

Obviamente, esto requiere que esté seguro de que ambos valores tienen el mismo número de lugares decimales.

Usé las respuestas de aquí y las puse en una función, puedes usarlas así:

is_first_floating_number_bigger 1.5 1.2
result="${__FUNCTION_RETURN}"

Una vez llamado, echo $resultserá 1en este caso, de lo contrario 0.

La función:

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

O una versión con salida de depuración:

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

Simplemente guarde la función en un .sharchivo separado e inclúyalo así:

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

Estaba publicando esto como respuesta a https://stackoverflow.com/a/56415379/1745001 cuando se cerró como un duplicado de esta pregunta, así que aquí está como se aplica aquí también:

Por simplicidad y claridad, simplemente use awk para los cálculos, ya que es una herramienta estándar de UNIX y es tan probable que esté presente como bc y mucho más fácil de trabajar sintácticamente.

Para esta pregunta:

$ 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

y para esa otra pregunta que se cerró como duplicación de esta:

$ 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...

awky herramientas como esta (te estoy mirando sed...) deberían relegarse al basurero de los proyectos antiguos, con un código que todo el mundo tiene demasiado miedo de tocar, ya que fue escrito en un lenguaje de nunca lectura.

O usted es el proyecto relativamente raro que necesita priorizar la optimización del uso de la CPU sobre la optimización del mantenimiento del código ... en cuyo caso, continúe.

Si no es así, ¿por qué no usar algo legible y explícito, como python? Tus compañeros codificadores y tu futuro yo te lo agradecerán. Puede usar en pythonlínea con bash como todos los demás.

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

Esta secuencia de comandos puede ayudar a comprobar si la grailsversión instalada es mayor que la mínima requerida. Espero eso ayude.

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

compruebe el código editado a continuación: -

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

Esto funciona bien.

Una solución que admite todas las notaciones posibles, incluida la notación científica con exponentes en mayúsculas y minúsculas (por ejemplo, 12.00e4):

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

Use korn shell, en bash puede que tenga que comparar la parte decimal por separado

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

Usando bashj ( https://sourceforge.net/projects/bashj/ ), un mutante bash con soporte java, solo escribe (y ES fácil de leer):

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

Por supuesto, la hibridación bashj bash / java ofrece mucho más ...

¿Qué tal esto? = 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