J'utilise un GNU/bc dans un script pour convertir un nombre d'une base
quelconque dans un autre base.
#!/bin/sh
echo -n " Si $VALEUR_SAISIE est en décimal, alors: "
echo `bc << !
obase=16; "hex="; $VALEUR_SAISIE
obase=10; "dec="; $VALEUR_SAISIE
obase=8 ; "oct="; $VALEUR_SAISIE
obase=2 ; "bin="; $VALEUR_SAISIE
!
`
Marche bien, le script renvoie:
Si 20 est en décimal, alors: hex=14 dec=20 oct=24 bin=10100
echo -n " Si $VALEUR_SAISIE est en héxa, alors: "
echo `bc << !
ibase=16; "hex="; $VALEUR_SAISIE
ibase=10; "dec="; $VALEUR_SAISIE
ibase=8 ; "oct="; $VALEUR_SAISIE
ibase=2 ; "bin="; $VALEUR_SAISIE
!
`
Marche mal, seule la valeur en décimal est juste, le script donne:
Si 20 est en héxa, alors: hex=32 dec=32 oct=16 bin=2
J'ai cru à un problème de obase, alors j'ai écrit ce qui suit et
effectivement les valeurs en octal et binaire sont justes, mais la
valeur héxadécimale n'est pas affiché avec des lettres.
Et je ne comprends pas les warnings.
echo -n " Si $VALEUR_SAISIE est en héxa, alors: "
echo `bc << !
ibase=16; obase=16; "hex="; $VALEUR_SAISIE
ibase=16; obase=10; "dec="; $VALEUR_SAISIE
ibase=16; obase=8 ; "oct="; $VALEUR_SAISIE
ibase=16; obase=2 ; "bin="; $VALEUR_SAISIE
!
`
Me renvoie:
Si 20 est en héxa, alors: Runtime warning (func=(main), adr=6): ibase
too large, set to 16
Runtime warning (func=(main), adr=6): ibase too large, set to 16
Runtime warning (func=(main), adr=6): ibase too large, set to 16
hex= 01 10 dec=20 oct=40 bin=100000
Merci de votre aide.
--
> On va peut-être savoir si un FreeBSDiste peut se reproduire avec un
> linuxien.
Ah ! C'est ça HURD ?
-+- fyr in Guide du linuxien pervers - "Linux transgenique" -+-
si ibase alors 16 vaut 22 en décimal (pour la deuxième déclaration de ibase) et dépasse la valeur maximale autorisée pour ibase d'où l'avertissement
H> Runtime warning (func=(main), adr=6): ibase too large, set to 16
--
Guy Decoux
Hugolino
Le Wed, 20 Jun 2007 08:17:56 +0200, ts a écrit:
"H" == Hugolino writes:
Salut et merci de chercher à m'aider... Tu as été un peu «brutal» dans ton quotage, je rajoute ce que je suppose être ce à quoi tu répondais...
echo -n " Si $VALEUR_SAISIE est en héxa, alors: " echo `bc << ! ibase; "hex="; $VALEUR_SAISIE ibase; "dec="; $VALEUR_SAISIE ibase=8 ; "oct="; $VALEUR_SAISIE ibase=2 ; "bin="; $VALEUR_SAISIE ! ` Marche mal, seule la valeur en décimal est juste, le script donne: Si 20 est en héxa, alors: hex2 dec2 oct bin=2
Ça, c'est OK, j'ai bien compris ce que tu veux dire, à savoir que si je passe 10 en argument à mon script et que j'étudie le cas où ibase (puisque je ne veux pas contraindre le yuser à spécifier la base), alors il est normal que la première ligne réponde hex puisque je n'ai pas spécifié la valeur de obase (qui par défaut vaut 10). Et on est bien d'accord, 10 en base héxa vaut 16 en obase par défaut. On dira que c'est au yuser de savoir trier la sortie puisque je ne lui impose pas de spécifier la base dans laquelle est exprimé l'argument. (Ou alors que je dois imposer au yuser de spécifier la base).
Bref, merci de tes lumières.
Je re-cite le troisème morceau de mon script:
echo -n " Si $VALEUR_SAISIE est en héxa, alors: " echo `bc << ! ibase; "hex="; $VALEUR_SAISIE ibase; "dec="; $VALEUR_SAISIE ibase=8 ; "oct="; $VALEUR_SAISIE ibase=2 ; "bin="; $VALEUR_SAISIE ! `
si ibase alors 16 vaut 22 en décimal (pour la deuxième déclaration de ibase) et dépasse la valeur maximale autorisée pour ibase d'où l'avertissement
H> Runtime warning (func=(main), adr=6): ibase too large, set to 16
Tu veux dire qu'une fois que j'ai posé ibase (première ligne), alors je dois uiliser une base héxadécimale à la deuxième ligne pour dire que je veux une base 16, soit ibase. ('tain, c(est ultra-vicieux, j'aurais jamais trouvé tout seul :)
donc je corrige mon script bc qui devient: 8<-----------8<---------8<----------8<----------8<----------8<----------8< echo -n ${GREEN}" Si ${YELLOW}$VALEUR_SAISIE${GREEN} est en héxa, alors: ${CYAN} " echo `bc << ! ibase; obase; "hex="; $VALEUR_SAISIE ibase; obase; "dec="; $VALEUR_SAISIE ibase; obase=8 ; "oct="; $VALEUR_SAISIE ibase; obase=2 ; "bin="; $VALEUR_SAISIE ! ` 8<-----------8<---------8<----------8<----------8<----------8<----------8<
Et si je lui passe 10 en argument, ça donne ça: Si 10 est en héxa, alors: Runtime warning (func=(main), adr=6): ibase too large, set to 16 Runtime warning (func=(main), adr=6): ibase too large, set to 16 hex= 16 dec oct bin000
Et là je ne comprends plus. Je m'attendais bien à avoir un warning pour le passage de la 3ème à la quatrième ligne à cause de cette histoire de 16 qui en base 16 vaut 22 alors que bc ne gère pas de base 22, mais pourquoi deux warnings ? À cause du passage de la 2ème à la troisième ligne ? Mais à la fin de la 2ème ligne ibase vaut 10, donc j'ai bien le droit d'écrire ibase au début de la 3ème ligne... Si je supprime cette troisième ligne, je n'ai bien qu'un seul warning, la sortie est:
Si 10 est en héxa, alors: Runtime warning (func=(main), adr=6): ibase too large, set to 16 hex= 16 dec bin000
Mais je ne compreds toujours pas pourquoi je n'aurais pas le droit d'écrire ibase alors que la base vaut 10 (ibase de la ligne 2).
Je sens bien que ton explication est sans doute la bonne mais il y a un truc qui cloche.
Merci.
--
Faut avoir du temps à perdre. Lorsqu'il est proféré sur Usenet, cet argument n'a absolument
aucune valeur. Hugo (né il y a 1 361 838 501 secondes)
Le Wed, 20 Jun 2007 08:17:56 +0200, ts a écrit:
"H" == Hugolino <hugolino@free.fr> writes:
Salut et merci de chercher à m'aider...
Tu as été un peu «brutal» dans ton quotage, je rajoute ce que je suppose
être ce à quoi tu répondais...
echo -n " Si $VALEUR_SAISIE est en héxa, alors: "
echo `bc << !
ibase; "hex="; $VALEUR_SAISIE
ibase; "dec="; $VALEUR_SAISIE
ibase=8 ; "oct="; $VALEUR_SAISIE
ibase=2 ; "bin="; $VALEUR_SAISIE
!
`
Marche mal, seule la valeur en décimal est juste, le script donne:
Si 20 est en héxa, alors: hex2 dec2 oct bin=2
Ça, c'est OK, j'ai bien compris ce que tu veux dire, à savoir que si je
passe 10 en argument à mon script et que j'étudie le cas où ibase
(puisque je ne veux pas contraindre le yuser à spécifier la base), alors
il est normal que la première ligne réponde hex puisque je n'ai pas
spécifié la valeur de obase (qui par défaut vaut 10). Et on est bien
d'accord, 10 en base héxa vaut 16 en obase par défaut. On dira que
c'est au yuser de savoir trier la sortie puisque je ne lui impose pas de
spécifier la base dans laquelle est exprimé l'argument. (Ou alors que je
dois imposer au yuser de spécifier la base).
Bref, merci de tes lumières.
Je re-cite le troisème morceau de mon script:
echo -n " Si $VALEUR_SAISIE est en héxa, alors: "
echo `bc << !
ibase; "hex="; $VALEUR_SAISIE
ibase; "dec="; $VALEUR_SAISIE
ibase=8 ; "oct="; $VALEUR_SAISIE
ibase=2 ; "bin="; $VALEUR_SAISIE
!
`
si ibase alors 16 vaut 22 en décimal (pour la deuxième déclaration de
ibase) et dépasse la valeur maximale autorisée pour ibase d'où
l'avertissement
H> Runtime warning (func=(main), adr=6): ibase too large, set to 16
Tu veux dire qu'une fois que j'ai posé ibase (première ligne), alors
je dois uiliser une base héxadécimale à la deuxième ligne pour dire que
je veux une base 16, soit ibase.
('tain, c(est ultra-vicieux, j'aurais jamais trouvé tout seul :)
donc je corrige mon script bc qui devient:
8<-----------8<---------8<----------8<----------8<----------8<----------8<
echo -n ${GREEN}" Si ${YELLOW}$VALEUR_SAISIE${GREEN} est en héxa, alors:
${CYAN} "
echo `bc << !
ibase; obase; "hex="; $VALEUR_SAISIE
ibase; obase; "dec="; $VALEUR_SAISIE
ibase; obase=8 ; "oct="; $VALEUR_SAISIE
ibase; obase=2 ; "bin="; $VALEUR_SAISIE
!
`
8<-----------8<---------8<----------8<----------8<----------8<----------8<
Et si je lui passe 10 en argument, ça donne ça:
Si 10 est en héxa, alors: Runtime warning (func=(main), adr=6): ibase
too large, set to 16
Runtime warning (func=(main), adr=6): ibase too large, set to 16
hex= 16 dec oct bin000
Et là je ne comprends plus. Je m'attendais bien à avoir un warning pour
le passage de la 3ème à la quatrième ligne à cause de cette histoire de
16 qui en base 16 vaut 22 alors que bc ne gère pas de base 22, mais
pourquoi deux warnings ? À cause du passage de la 2ème à la troisième
ligne ? Mais à la fin de la 2ème ligne ibase vaut 10, donc j'ai bien le
droit d'écrire ibase au début de la 3ème ligne...
Si je supprime cette troisième ligne, je n'ai bien qu'un seul warning,
la sortie est:
Si 10 est en héxa, alors: Runtime warning (func=(main), adr=6): ibase
too large, set to 16
hex= 16 dec bin000
Mais je ne compreds toujours pas pourquoi je n'aurais pas le droit
d'écrire ibase alors que la base vaut 10 (ibase de la ligne 2).
Je sens bien que ton explication est sans doute la bonne mais il y a
un truc qui cloche.
Merci.
--
Faut avoir du temps à perdre.
Lorsqu'il est proféré sur Usenet, cet argument n'a absolument
aucune valeur.
Hugo (né il y a 1 361 838 501 secondes)
Salut et merci de chercher à m'aider... Tu as été un peu «brutal» dans ton quotage, je rajoute ce que je suppose être ce à quoi tu répondais...
echo -n " Si $VALEUR_SAISIE est en héxa, alors: " echo `bc << ! ibase; "hex="; $VALEUR_SAISIE ibase; "dec="; $VALEUR_SAISIE ibase=8 ; "oct="; $VALEUR_SAISIE ibase=2 ; "bin="; $VALEUR_SAISIE ! ` Marche mal, seule la valeur en décimal est juste, le script donne: Si 20 est en héxa, alors: hex2 dec2 oct bin=2
Ça, c'est OK, j'ai bien compris ce que tu veux dire, à savoir que si je passe 10 en argument à mon script et que j'étudie le cas où ibase (puisque je ne veux pas contraindre le yuser à spécifier la base), alors il est normal que la première ligne réponde hex puisque je n'ai pas spécifié la valeur de obase (qui par défaut vaut 10). Et on est bien d'accord, 10 en base héxa vaut 16 en obase par défaut. On dira que c'est au yuser de savoir trier la sortie puisque je ne lui impose pas de spécifier la base dans laquelle est exprimé l'argument. (Ou alors que je dois imposer au yuser de spécifier la base).
Bref, merci de tes lumières.
Je re-cite le troisème morceau de mon script:
echo -n " Si $VALEUR_SAISIE est en héxa, alors: " echo `bc << ! ibase; "hex="; $VALEUR_SAISIE ibase; "dec="; $VALEUR_SAISIE ibase=8 ; "oct="; $VALEUR_SAISIE ibase=2 ; "bin="; $VALEUR_SAISIE ! `
si ibase alors 16 vaut 22 en décimal (pour la deuxième déclaration de ibase) et dépasse la valeur maximale autorisée pour ibase d'où l'avertissement
H> Runtime warning (func=(main), adr=6): ibase too large, set to 16
Tu veux dire qu'une fois que j'ai posé ibase (première ligne), alors je dois uiliser une base héxadécimale à la deuxième ligne pour dire que je veux une base 16, soit ibase. ('tain, c(est ultra-vicieux, j'aurais jamais trouvé tout seul :)
donc je corrige mon script bc qui devient: 8<-----------8<---------8<----------8<----------8<----------8<----------8< echo -n ${GREEN}" Si ${YELLOW}$VALEUR_SAISIE${GREEN} est en héxa, alors: ${CYAN} " echo `bc << ! ibase; obase; "hex="; $VALEUR_SAISIE ibase; obase; "dec="; $VALEUR_SAISIE ibase; obase=8 ; "oct="; $VALEUR_SAISIE ibase; obase=2 ; "bin="; $VALEUR_SAISIE ! ` 8<-----------8<---------8<----------8<----------8<----------8<----------8<
Et si je lui passe 10 en argument, ça donne ça: Si 10 est en héxa, alors: Runtime warning (func=(main), adr=6): ibase too large, set to 16 Runtime warning (func=(main), adr=6): ibase too large, set to 16 hex= 16 dec oct bin000
Et là je ne comprends plus. Je m'attendais bien à avoir un warning pour le passage de la 3ème à la quatrième ligne à cause de cette histoire de 16 qui en base 16 vaut 22 alors que bc ne gère pas de base 22, mais pourquoi deux warnings ? À cause du passage de la 2ème à la troisième ligne ? Mais à la fin de la 2ème ligne ibase vaut 10, donc j'ai bien le droit d'écrire ibase au début de la 3ème ligne... Si je supprime cette troisième ligne, je n'ai bien qu'un seul warning, la sortie est:
Si 10 est en héxa, alors: Runtime warning (func=(main), adr=6): ibase too large, set to 16 hex= 16 dec bin000
Mais je ne compreds toujours pas pourquoi je n'aurais pas le droit d'écrire ibase alors que la base vaut 10 (ibase de la ligne 2).
Je sens bien que ton explication est sans doute la bonne mais il y a un truc qui cloche.
Merci.
--
Faut avoir du temps à perdre. Lorsqu'il est proféré sur Usenet, cet argument n'a absolument
aucune valeur. Hugo (né il y a 1 361 838 501 secondes)
Jogo
Sur fr.comp.os.unix, Hugolino disait :
Je sens bien que ton explication est sans doute la bonne mais il y a un truc qui cloche.
C'est pourtant très simple : à partir du moment où tu lui as dit ibase, toutes les valeurs numériques sont interprétées en base hexa. Il faut donc lui dire :
Je sens bien que ton explication est sans doute la bonne mais il y a
un truc qui cloche.
C'est pourtant très simple : à partir du moment où tu lui as dit
ibase, toutes les valeurs numériques sont interprétées en base hexa.
Il faut donc lui dire :
Je sens bien que ton explication est sans doute la bonne mais il y a un truc qui cloche.
C'est pourtant très simple : à partir du moment où tu lui as dit ibase, toutes les valeurs numériques sont interprétées en base hexa. Il faut donc lui dire :
Bon, une meilleure réponse a été donnée par Jogo, mais vous faites toujours la même erreur
H> donc je corrige mon script bc qui devient: H> 8<-----------8<---------8<----------8<----------8<----------8<----------8< H> echo -n ${GREEN}" Si ${YELLOW}$VALEUR_SAISIE${GREEN} est en héxa, alors: H> ${CYAN} " H> echo `bc << ! H> ibase; obase; "hex="; $VALEUR_SAISIE H> ibase; obase; "dec="; $VALEUR_SAISIE H> ibase; obase=8 ; "oct="; $VALEUR_SAISIE H> ibase; obase=2 ; "bin="; $VALEUR_SAISIE H> ! H> ` H> 8<-----------8<---------8<----------8<----------8<----------8<----------8<
H> Et si je lui passe 10 en argument, ça donne ça: H> Si 10 est en héxa, alors: Runtime warning (func=(main), adr=6): ibase H> too large, set to 16 H> Runtime warning (func=(main), adr=6): ibase too large, set to 16 H> hex= 16 dec oct bin000
H> Et là je ne comprends plus. Je m'attendais bien à avoir un warning pour H> le passage de la 3ème à la quatrième ligne à cause de cette histoire de H> 16 qui en base 16 vaut 22 alors que bc ne gère pas de base 22, mais H> pourquoi deux warnings ? À cause du passage de la 2ème à la troisième H> ligne ? Mais à la fin de la 2ème ligne ibase vaut 10, donc j'ai bien le H> droit d'écrire ibase au début de la 3ème ligne...
À la fin de la deuxième ligne ibase vaut 10 en *hexadécimal*, la valeur que vous lui donnez est interprétée en fonction de la base qu'il a et que vous avez changé à 16 en première ligne.
Donc faire
moulon% bc -q # a cette étape il est en base 10, les valeurs que vous lui donnerez seront # interprétées dans cette base ibase # il s'est mis en base 16, les valeurs d'entrée seront interprétées dans # cette base ibase # vous lui avez donné la valeur 10 en *hexa* donc 16 en décimal ==> il n'a # pas changé la valeur d'ibase ibase # ce 16 est toujours interpreté en *hexa*, donc il a la valeur 22 en # décimal ce qui ne lui plait pas moulon%
Vous faites la même erreur avec obase
moulon% bc -q ibase # en entrée en base 16 obase # en sortie en base 22 (16 en *hexa*, il a changé ibase) 16 # 16 en hexa 01 00 # donne 10 en base 22 10 # 10 en hexa 16 # donne 16 en base 22 moulon%
--
Guy Decoux
"H" == Hugolino <hugolino@free.fr> writes:
Bon, une meilleure réponse a été donnée par Jogo, mais vous faites
toujours la même erreur
H> donc je corrige mon script bc qui devient:
H> 8<-----------8<---------8<----------8<----------8<----------8<----------8<
H> echo -n ${GREEN}" Si ${YELLOW}$VALEUR_SAISIE${GREEN} est en héxa, alors:
H> ${CYAN} "
H> echo `bc << !
H> ibase; obase; "hex="; $VALEUR_SAISIE
H> ibase; obase; "dec="; $VALEUR_SAISIE
H> ibase; obase=8 ; "oct="; $VALEUR_SAISIE
H> ibase; obase=2 ; "bin="; $VALEUR_SAISIE
H> !
H> `
H> 8<-----------8<---------8<----------8<----------8<----------8<----------8<
H> Et si je lui passe 10 en argument, ça donne ça:
H> Si 10 est en héxa, alors: Runtime warning (func=(main), adr=6): ibase
H> too large, set to 16
H> Runtime warning (func=(main), adr=6): ibase too large, set to 16
H> hex= 16 dec oct bin000
H> Et là je ne comprends plus. Je m'attendais bien à avoir un warning pour
H> le passage de la 3ème à la quatrième ligne à cause de cette histoire de
H> 16 qui en base 16 vaut 22 alors que bc ne gère pas de base 22, mais
H> pourquoi deux warnings ? À cause du passage de la 2ème à la troisième
H> ligne ? Mais à la fin de la 2ème ligne ibase vaut 10, donc j'ai bien le
H> droit d'écrire ibase au début de la 3ème ligne...
À la fin de la deuxième ligne ibase vaut 10 en *hexadécimal*, la valeur
que vous lui donnez est interprétée en fonction de la base qu'il a et que
vous avez changé à 16 en première ligne.
Donc faire
moulon% bc -q
# a cette étape il est en base 10, les valeurs que vous lui donnerez seront
# interprétées dans cette base
ibase
# il s'est mis en base 16, les valeurs d'entrée seront interprétées dans
# cette base
ibase
# vous lui avez donné la valeur 10 en *hexa* donc 16 en décimal ==> il n'a
# pas changé la valeur d'ibase
ibase
# ce 16 est toujours interpreté en *hexa*, donc il a la valeur 22 en
# décimal ce qui ne lui plait pas
moulon%
Vous faites la même erreur avec obase
moulon% bc -q
ibase # en entrée en base 16
obase # en sortie en base 22 (16 en *hexa*, il a changé ibase)
16 # 16 en hexa
01 00 # donne 10 en base 22
10 # 10 en hexa
16 # donne 16 en base 22
moulon%
Bon, une meilleure réponse a été donnée par Jogo, mais vous faites toujours la même erreur
H> donc je corrige mon script bc qui devient: H> 8<-----------8<---------8<----------8<----------8<----------8<----------8< H> echo -n ${GREEN}" Si ${YELLOW}$VALEUR_SAISIE${GREEN} est en héxa, alors: H> ${CYAN} " H> echo `bc << ! H> ibase; obase; "hex="; $VALEUR_SAISIE H> ibase; obase; "dec="; $VALEUR_SAISIE H> ibase; obase=8 ; "oct="; $VALEUR_SAISIE H> ibase; obase=2 ; "bin="; $VALEUR_SAISIE H> ! H> ` H> 8<-----------8<---------8<----------8<----------8<----------8<----------8<
H> Et si je lui passe 10 en argument, ça donne ça: H> Si 10 est en héxa, alors: Runtime warning (func=(main), adr=6): ibase H> too large, set to 16 H> Runtime warning (func=(main), adr=6): ibase too large, set to 16 H> hex= 16 dec oct bin000
H> Et là je ne comprends plus. Je m'attendais bien à avoir un warning pour H> le passage de la 3ème à la quatrième ligne à cause de cette histoire de H> 16 qui en base 16 vaut 22 alors que bc ne gère pas de base 22, mais H> pourquoi deux warnings ? À cause du passage de la 2ème à la troisième H> ligne ? Mais à la fin de la 2ème ligne ibase vaut 10, donc j'ai bien le H> droit d'écrire ibase au début de la 3ème ligne...
À la fin de la deuxième ligne ibase vaut 10 en *hexadécimal*, la valeur que vous lui donnez est interprétée en fonction de la base qu'il a et que vous avez changé à 16 en première ligne.
Donc faire
moulon% bc -q # a cette étape il est en base 10, les valeurs que vous lui donnerez seront # interprétées dans cette base ibase # il s'est mis en base 16, les valeurs d'entrée seront interprétées dans # cette base ibase # vous lui avez donné la valeur 10 en *hexa* donc 16 en décimal ==> il n'a # pas changé la valeur d'ibase ibase # ce 16 est toujours interpreté en *hexa*, donc il a la valeur 22 en # décimal ce qui ne lui plait pas moulon%
Vous faites la même erreur avec obase
moulon% bc -q ibase # en entrée en base 16 obase # en sortie en base 22 (16 en *hexa*, il a changé ibase) 16 # 16 en hexa 01 00 # donne 10 en base 22 10 # 10 en hexa 16 # donne 16 en base 22 moulon%
