Discussion :

[deubelte]

Bonjour
je n'arrive pas à comprendre le code suivant:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
template <unsigned long N>
struct binary{
static unsigned const value
 =binary<N/10>::value<<1 |N%10
};

Pas au niveau de la syntaxe, mais au niveau de l'exécution de l'instruction.
Que fait:
binary<N/10>::value<<1 |N%10

Dans quel ordre cela se lit?
Si par exemple N=139,
N%10=9

On décale de 1 bit binary<N/10>::value

On fait ensuite l'addition binaire de N%10 et de binary<N/10>::value<<1.
J'imagine que cela renvoie le nombre en décimale d'un binaire?

merci

[méphistopheles]

Bonjour.

si on applique les priorités des opérateurs, l'expression est en clair:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

(binary<(N/10)>::value<<1 )|(N%10)

en gros, on a binary<(N/10)>*2 + (N%10)

étant donnée que la suite des N/10 va converger vers 0, on vas parler en fonction de binary(0) que nous noterons U0 (il doit exister uns spécialisation de ta classe pour cette valeur)
on a donc
binary(x=[1...9])=U0*2+x
binary(x=[10...19])=U0*4+(x-10) +2
binary(x=[20...29])=U0*8+(x-20) +4
...
binary(x!=0)=binary((x/10)*10) +x%10

comme à mon avise binary(0)=0
ça nous fait :
0,1,2,3,4,...,9,2,3,4,............

puis à partir de binary 100,
binary(100)=binary(10)*2=4
binary(101)=binary(10)*2+1=5
..
binary(110)=binary(11)*2=6
etc...
on a donc un convertisseur depuis des nombres notés en binaire mais sur une base digitale vers leurs valeur réelle. pour ma part, je trouve que c'est un peu tordu, mais bon,c'est plutot bien trouvé

bonne chance pour la suite

[deubelte]

Je ne comprend pas pourquoi tu as mis un 8 devant U0

binary(x=[20...29])=U0*8+(x-20) +4

j'aurais mis 4.

[Luc Hermitte]

Ce n'est pas une addition.
C'est un OU binaire (/bit à bit). => 12->2, 13->3, etc.

(Je ne cache pas que l'intérêt m'échappe encore -- avec un décalage de 4, on aurait eu des plages différentes (et donc une vraie addition arithmétique obfusquée) entre le modulo et le dividende, et donc un encodage en BCD, mais là ce n'est pas le cas, on ne décale que de 1 ce qui implique un recouvrement et ... n'importe quoi au final.)

[méphistopheles]

Ce n'est pas une addition.
C'est un OU binaire (/bit à bit). => 12->2, 13->3, etc.

(Je ne cache pas que l'intérêt m'échappe encore -- avec un décalage de 4, on aurait eu des plages différentes (et donc une vraie addition arithmétique obfusquée) entre le modulo et le dividende, et donc un encodage en BCD, mais là ce n'est pas le cas, on ne décale que de 1 ce qui implique un recouvrement et ... n'importe quoi au final.)

J'avoue que j'ai un peu simplifié avec cette histoire d'addition, mais en supposant U0=0 le résultat est le même:
binary(x=[0...9])=x
binary(10)=2 //(00|10==10)
binary(11)=3
binary(12)=2 //(10|10==10) //mais on s'en fiche un peu
binary(13)=3 //mais on s'en fiche un peu
binary(14)=6 //mais on s'en fiche un peu
...
binary(100)=binary(10)<<1=4
binary(101)=5
binary(102)=6//mais on s'en fiche un peu
binary(103)=7//mais on s'en fiche un peu
...
binary (110)=binary(11)<<1=6
binary (111)=7
binary (112)=6//mais on s'en fiche un peu
binary (113)=7//mais on s'en fiche un peu
...
binary(1000)=binary(100)<<1=8

donc ça marche.

la fonction inverse serait:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
template <unsigned long N>
struct decbin{
static unsigned const value
 =10*decbin<N<<1>::value + N%2 
};
template <>
struct decbin<0>{
static unsigned const value
 =0;
};

ou encore pour rester dans le même style obscurantiste

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
template <unsigned long N>
struct decbin{
static unsigned const value
 =10*decbin<N<<1>::value | (N&1)
};
template <>
struct decbin<0>{
static unsigned const value
 =0;
};

voilà. par contre, si la spécialisation de binary en 0 n'ets pas 0, je ne vois pas ce que ça peut être

bonne chance

[deubelte]

Voila mon calcul:


Si N<=9, N%10=N, donc binary(x)=2U0+x

Si 10<=N<=19 alors N%10=N-10, et N/10 est compris entre 1 et 2, (convertir en int, cela vaut 1) donc

binary(N)=2*binary(N/10)+N%10
=2*binary(1)+x-10=2*(2U0+1)+x-10=4U0+2+(x-10)


Si 20<=N<=29 alos N%20=N-20 et N/10 est compris entre 2 et 3 (convertir en int, cela vaut 2) donc

binary(N)=2*binary(N/10)+N%10
=2*binary(2)+(x-20)=2*(2U0+2)+x-20=4U0+4+(x-20)

Si 30<=N<=39 alos N%10=N-30 et N/10 est compris entre 3 et 4 (converti en int, cela vaut 3) donc

binary(N)=2*binary(N/10)+N%10
=2*binary(3)+N-30=2*(2U0+3)+(x-30)=4U0+6+(x-30)

[méphistopheles]

Voila mon calcul:


Si N<=9, N%10=N, donc binary(x)=2U0+x

en fait non car "|" n'est pas équivalent à '+'. C'est vrai si U0 =0 (ce que j'ai supposé dans mon exemple afin d'avoir binary(0)=binary(N=0) (ce qui semble logique) )

Si 10<=N<=19 alors N%10=N-10, et N/10 est compris entre 1 et 2, (convertir en int, cela vaut 1) donc

binary(N)=2*binary(N/10)+N%10
=2*binary(1)+x-10=2*(2U0+1)+x-10=4U0+2+(x-10)


Si 20<=N<=29 alos N%20=N-20 et N/10 est compris entre 2 et 3 (convertir en int, cela vaut 2) donc

binary(N)=2*binary(N/10)+N%10
=2*binary(2)+(x-20)=2*(2U0+2)+x-20=4U0+4+(x-20)

Si 30<=N<=49 alos N%10=N-30 et N/10 est compris entre 3 et 4 (converti en int, cela vaut 3) donc

binary(N)=2*binary(N/10)+N%10
=2*binary(3)+N-30=2*(2U0+3)+(x-30)=4U0+6+(x-30)

Si on oublie le fait que '|' n'est pas égal à '+', c'est bien plus juste que ce que j'avais mis dans mon post #2. Les bonnes valeurs (si je ne me suis pas trompé ) sont dans mon post #5 mais ce sur quoi je voulais insister est que les valeurs qui n'ont autre chose que des 0 ou des 1 n'ont pas d'intérêt dans le cadre de cette fonction qui est une espèce de pseudo-conversion binaire décimal (enfin de la représentation binaire dans un affichage décimal à une représentation numérique pour être plus exact).

en gros, si je donne 10101001, la fonction doit me sortir 169. par contre elle n'est pas censée avoir un quelconque résultat valable pour des nombres intégrant tout autre numéro que 1 ou 0.

[deubelte]

C'est vrai si U0 =0 (ce que j'ai supposé dans mon exemple afin d'avoir binary(0)=binary(N=0) (ce qui semble logique) )

C'est le cas, en tout cas dans l'exemple que j'ai donné


C'est exemple est issu du livre C++ Template MetaProgramming. De Abrahams.

[méphistopheles]

C'est le cas, en tout cas dans l'exemple que j'ai donné


C'est exemple est issu du livre C++ Template MetaProgramming. De Abrahams.

ce qui m'étonne, c'est que je ne suis pas sûr que ce soit optimal: même si le template est évalué a l'avance, je ne suis pas sûr que le résultat des expressions soit précalculé.... et même si le nombre de calculs doit être en quelque chose comme O(4.log(N)) soit 4 par "décimale" ("duale" ?) le mode de représentation me parait vraiment curieux et pas performant comparé à un mode "string"(un décalage de bit par valeur plus passage à la valeur suivante, soit la moitié en temps)...

[Joel F]

ce qui m'étonne, c'est que je ne suis pas sûr que ce soit optimal: même si le template est évalué a l'avance, je ne suis pas sûr que le résultat des expressions soit précalculé....

euh si :{ c'est genre le principe de la meta-prog, au final t'as valeur est entierement évaluée par le compilateur qui ensuite fait de la propagation de constante

[méphistopheles]

euh si :{ c'est genre le principe de la meta-prog, au final t'as valeur est entierement évaluée par le compilateur qui ensuite fait de la propagation de constante

Ok, j'avais un doute , je range ma mauvaise langue.

Merci pour l'info

[Goten]

Note que le bout de code est juste là pour avoir un truc abordable (ie simple) afin de montrer la TMP au lecteur facilement, il mentionne bien que le but principal n'est pas de faire du calcul. (même si oui Joel je sais que ça peut être intéressant de le faire :p)