Comparaison de nombres flottants en shell

Version imprimable

27/12/2006, 14h10
the_ionic

Comparaison de nombres flottants en shell
Bonjour à tous...

Voilà, je gère des numéros de versions d'une application.
Au cours d'un lancement d'application, j'ai besoin de comparer le numéro actuelle de la version de l'appli avec le numéro de la version d'un client, enfin bref, je veux comparer en fait deux flottant vu que la version est de la forme: x.y (x et y étant des entiers).

La comparaison doit se faire dans un script shell.

Alors moi, je suis parti tête la première en programmant un truc du style:
Code:

1 2 3 4 5 if [ $VERSION_APPLI > $VERSION_CLIENT ] then echo "je fais le bon traitement ici" fi
Je teste mon programme avec VERSION_APPLI valant 3.1 et VERSION_CLIENT valant 4.0 (j'ai bien vérifié en faisant des echo) et le programme rentre quand même dans la conditionnelle or il ne devrait pas.
J'ai cherché un peu à droite à gauche et j'ai vu que y'avait la notion de comparaison de chaine et de numérique.
J'ai donc essayé en remplaçant le symbole '>' par '-gt' mais ça, ça marche que pour les entiers.
Donc mon souci, comment faire pour que ça marche avec du flottant?

J'ai bien eu une idée, c'est de multiplier les numéro de version et de comparer avec '-gt' mais ça marche pas non plus.

Par exemple, si j'exécute:
Code:

1 2 echo $(( $VERSION_APPLI*10 ))
ça me retourne:
Code:

1 2 ./shVoxDb: line 113: 3.1*10 : syntax error in expression (error token is ".1*10 ")
comme si mon shell n'était pas capable de gérer les flottants... quelqu'un a une idée???
Merci d'avance!
27/12/2006, 14h18
frp31

au pire tu peux utiliser BC pour les calculs un peu complexes

Code:

echo " $i * 10 " | bc

en fait je crois même qu'il y a la fonction comparative pour flottants dans BC mais je suis pas sur à vérifier dans le man page.
27/12/2006, 14h46
ripat

Et en échappant <?

Code:

if [ $VERSION_APPLI \> $VERSION_CLIENT ]

ou

Code:

if [[ $VERSION_APPLI > $VERSION_CLIENT ]]

Quel shell utilises-tu?
27/12/2006, 15h06
narmataru

Bonjour,
pour les chiffres à virgule il faut utiliser la commande 'bc' :

Citation:

narma@linimi:~$ a=1.5
narma@linimi:~$ b=1.6
narma@linimi:~$ if [ $(echo " $a < $b" | bc) -eq 1 ]; then echo "ok"; fi
ok
narma@linimi:~$ b=1.49
narma@linimi:~$ if [ $(echo " $a < $b" | bc) -eq 1 ]; then echo "ok"; fi
narma@linimi:~$ b=1.3
narma@linimi:~$ if [ $(echo " $a < $b" | bc) -eq 1 ]; then echo "ok"; fi
narma@linimi:~$ a=1.001
narma@linimi:~$ if [ $(echo " $a < $b" | bc) -eq 1 ]; then echo "ok"; fi
ok
27/12/2006, 15h14
the_ionic
ripat>>
J'utilise sh.
Et apparemment, il ne peut vraiment pas prendre en compte les flottants à part sous forme de chaines, donc toutes comparaisons s'avèrera foireuse.

La solution donnée plus haut convient, ça donne:
Code:

1 2 3 4 5 6 COMP=$(echo "$VERSION_APPLI>$VERSION_CLIENT" | bc) if [ $COMP -eq 1 ] then echo "mon traitement" fi
Donc merci beaucoup!
Il me reste un problème par contre, c'est que ma version peut en fait avoir une lettre dedans, après la virgule, du genre 3.1a alors là, je vois pas comment faire.
En fait, je ne sais pas comment fonctionne la comparaison de chaine, donc je ne vois pas pourquoi elle ne réussit pas dans le cas que j'ai décris dans mon premier post (3.1 et 4.0). Quelqu'un peut t'il m'expliquer comment ça marche quand on compare deux chaines bon, du point de vue égalité, je vois comment ça marche, mais du point de vue supérieur, inférieur à, quels critères sont utilisés?

Merci d'avance
27/12/2006, 16h17
frp31

heu limiter la lecture à x.y ? pour éviter les lettres ? ok je sors :mrgreen:
27/12/2006, 16h35
narmataru

Je pencherais plutot dans une découpe de chaine via awk/sed pour récupérer le numéro de version majeur, le mineur puis la lettre et ainsi tester ces valeurs une par une...
27/12/2006, 16h41
the_ionic

Citation:

Envoyé par narmataru

Je pencherais plutot dans une découpe de chaine via awk/sed pour récupérer le numéro de version majeur, le mineur puis la lettre et ainsi tester ces valeurs une par une...

Ouaip, je crois que je vais me lancer la-dedans, merci pour l'idée!

Citation:

Envoyé par the_ionic

ripat>>
J'utilise sh.
Et apparemment, il ne peut vraiment pas prendre en compte les flottants à part sous forme de chaines, donc toutes comparaisons s'avèrera foireuse.

Bash dispose d'un opérateur de comparaison de chaînes.

man bash ->
Code:

1 2 3 4 5 chaîne_1 < chaîne_2 Vrai si chaîne_1 se trouve avant chaîne_2 dans l'ordre lexicographique de la localisation en cours. chaîne_1 > chaîne_2 Vrai si chaîne_1 se trouve après chaîne_2 dans l'ordre lexicographique de la localisation en cours.
Il est donc tout à fait possible de comparer des chaînes comme
1.25 1.30
1.25 1.3
1.2a 1.2c

etc..

Attention toutefois:

Code:

[[ "12.2a" > "12.25" ]] && echo "plus grand"

renvoie "plus grand"

28/12/2006, 09h41
PRomu@ld

Citation:

je veux comparer en fait deux flottant vu que la version est de la forme: x.y (x et y étant des entiers).

Attention, c'est une comparaison d'entier qu'il faut faire, la comparaison de flottant n'est pas exacte sur un shell ( à moins d'être sur du contraire). De plus pour ton problème, il suffit de découper comme on te l'a suggéré en majeur, mineur révision.

Tu compare dans l'ordre et il ne devrait pas y avoir de souci.
28/12/2006, 09h50
the_ionic

ripat>>
Ok, en fait tu m'avais donné la bonne solution dès le début (à part effectivement dans le cas que tu cites avec les lettres) mais je n'avais pas vu les doubles-crochets... pourquoi a t'on besoin de mettre [[ ]] au lieu de []?
Par contre, je comprends dans ton exemple que la lettre doit être placé avant le chiffre dans l'alphabet mais en cherchant sur le net, je trouve pas une table qui me donne l'ordre lexicographique. Ok, c'est l'alphabet, mais pour moi, dans l'alphabet, y'avait que des lettres, alors les chiffres sont tous placés après, c'est ça?

PRomu@ld>>
Comme dit précédemment, je vais prendre ta solution, je vais me lancer la dedans ce matin car je ne m'y connais pas trop en awk/sed.

Merci.
28/12/2006, 15h22
the_ionic

Oups, j'avais rajouté une grosse bêtise, désolé!

Je rajoute la solution me semble-t'il qui marche pour le problème au cas ou quelqu'un se trouve face au problème...

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
 
# Pour comparer les versions, il ne faut pas utiliser la comparaison lexicographique directement
# car elle entraine des resultats faux dans certains cas
# On sépare donc un numéro de version en trois - Le prefixe (nombre entier), le mineur (chiffre), et la release (lettre)
# La variable COPY_SCRIPT indique si il est necessaire de copier les
# scripts de l'application vers le client
 
COPY_SCRIPT="0"
VERSION_CLIENT=4.2
VERSION_APPLI=4.1a
SUFFIX_CLIENT=$(echo $VERSION_CLIENT | awk -F . '{ print $2 }')
PREFIX_CLIENT=$(echo $VERSION_CLIENT | awk -F . '{ print $1 }')
MINOR_CLIENT=$(echo $SUFFIX_CLIENT | sed -e 's/[a-z]//' ) 
RELEASE_CLIENT=$(echo $SUFFIX_CLIENT | sed -e 's/[0-9]//' )
 
 
SUFFIX_APPLI=$(echo $VERSION_APPLI | awk -F . '{ print $2 }')
PREFIX_APPLI=$(echo $VERSION_APPLI | awk -F . '{ print $1 }')
MINOR_APPLI=$(echo $SUFFIX_APPLI | sed -e 's/[a-z]//' ) 
RELEASE_APPLI=$(echo $SUFFIX_APPLI | sed -e 's/[0-9]//' )
 
 
 
# Si les version de l'application et du client sont différentes
if [ $VERSION_APPLI != $VERSION_CLIENT ]
then
	# La migration automatique a été activée
	if [ $AUTO_MIGRATION = "true" ]
	then
		#On compare d'abord le prefixe en utilisant la comparaison arithmétique
		if [ $PREFIX_APPLI -ge $PREFIX_CLIENT ]
		then 
			if [ $PREFIX_APPLI -eq $PREFIX_CLIENT ]
			then
				echo "PREFIX APPLI EGAL"
				if [ $MINOR_APPLI -ge $MINOR_CLIENT ]
				then
					if [ $MINOR_APPLI -eq $MINOR_CLIENT ]
					then
						echo "MINOR APPLI EGAL"
						if [[ $RELEASE_APPLI > $RELEASE_CLIENT ]]
						then
						COPY_SCRIPT="1"
						fi
					else
						echo "MINOR APPLI PLUS GRAND"
						COPY_SCRIPT = "1"
					fi
           			fi
           		else
           			echo "PREFIX APPLI PLUS GRAND"
           			COPY_SCRIPT="1"
   			fi
		fi
 
		if [ $COPY_SCRIPT == "1" ]
		then 
			echo "LE TRAITEMENT A EFFECTUER"
		fi

Merci à tous et je suis preneur de critiques sur ma solution...

Tu peux encore réduire ton script en jouant sur le test logique.

Par exemple:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 #! /usr/bin/ksh v1="12.2A" v2="12.2b" PREFIX_1=${v1%%+([a-zA-Z])} SUFFIX_1=${v1##+([0-9.])} PREFIX_2=${v2%%+([a-zA-Z])} SUFFIX_2=${v2##+([0-9.])} if [[ $PREFIX_1 > $PREFIX_2 ]] || ([[ $PREFIX_1 == $PREFIX_2 ]] && [[ $SUFFIX_1 > $SUFFIX_2 ]]) then echo "$v1 plus grand que $v2" fi
Si tu ne disposes pas du shell Korn (quel dommage!), remplace les splits des préfixes/suffixes par sed. Le test logique reste identique.
Code:

1 2 3 4 5 PREFIX_1=$(echo $v1 | sed -e 's/[a-z]//' ) SUFFIX_1=$(echo $v1 | sed -e 's/[0-9]//' ) PREFIX_2=$(echo $v2 | sed -e 's/[a-z]//' ) SUFFIX_2=$(echo $v2 | sed -e 's/[0-9]//' )
Pour info, un timing comparé des deux scripts donne:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 Ton script bash real 0m0.038s user 0m0.040s sys 0m0.000s Bash (ma version) real 0m0.030s user 0m0.030s sys 0m0.000s Le script Korn real 0m0.002s user 0m0.000s sys 0m0.000s
Le Korn est souvent plus rapide et en plus, ici, on ne fait plus appel à awk ou sed.