Glissement de bits

Version imprimable

12/11/2022, 08h15
rtg57

2 pièce(s) jointe(s)

Glissement de bits

Bonjour,

Attention ceci n'est pas un devoir scolaire, j'ai passé l'âge :D

Quelqu'un aurait-il une idée pour réaliser un algorithme qui opère un balayage de bits comme dans de l'illustration ci-dessous ?
Pièce jointe 628829

Ou comme dans celle-ci:
Pièce jointe 628830

Remarque importante: l'ordre de déplacement des bits n'a pas d'importance.
L'objectif est de garantir que toutes les combinaisons possibles sont réalisées.
J'ai dessiné ce tableau pour avoir une idée visuelle des combinaisons possibles.
Sauf que la réalisation des combinaisons dans cet ordre n'est pas facile...

Il y a peut être une autre progression à imaginer...
Cet algorithme doit pouvoir fonctionner en partant de différentes configurations ayant plus ou moins de bits 'forts' allumés, pour les descendre vers leur position faible.
Par exemple:
0000 0000 0011 1111 0000 0000 0000 0000

deviendra:
0000 0000 0000 0000 0000 0000 0011 1111

Merci de votre attention.
12/11/2022, 08h49
mathieu

dans la 1re image vous cherchez les nombres avec 2 bits à 1. et dans la 2e image, il s'agit de 3 bits à 1.
est ce que ça fait partie du même traitement qui continue jusqu'à 8 bits à 1 ou alors il s'agit de 2 traitements différents ?
12/11/2022, 09h48
WhiteCrow

Bonjour,

il y a différentes manières d'approcher le problème.

On peut dans un premier temps voir le problème comme déplacer 1 bit pour avoir la configuration suivante. Ici un algorithme possible est relativement simple et consiste schématiquement à scanner les bits de droite à gauche, compter ceux qu'on ne peut déplacer d'une position à droite. Si on tombe sur un bit déplaçable on le déplace, on ajoute à sa suite le nombre de bits indéplaçables on fait ce qu'on veut et on recommence. Si on ne trouve aucun bit déplaçable c'est que toutes les combinaisons ont été scannées. Le premier mot étant celui ayant tous les bits calés à gauche.

Exemple : si on part de 1100 on aboutit successivement à 1010, 1001, 0110, 0101 et 0011 qui ne comporte plus de bits déplaçables.

On peut également approcher ce problème sous l'angle des indices des bits positionnés. Par exemple 11100 correspond à (5,4,3). On utilisera un algorithme similaire au précédent.

Une source très intéressante est le TAOCP de Knuth, Volume 4 Fascicule 3a Generating all combination.
12/11/2022, 11h22
rtg57

Bonjour,

merci à vous deux pour l'intérêt que vous portez à mon problème.

Pour Mathieu: Les 2 tableaux représentent des traitements différents, j'aurai pu le préciser.
Dès que tous les bits ont atteint 'le bord droit', le traitement est terminé.

Pour WhiteCrow: Merci pour le lien, je ne connaissais pas et je sens que cet ouvrage va me passionner.

Je laisse ouvert la discussion, au cas où il y aurait d'autres suggestions...

@ bientôt...
12/11/2022, 11h31
tbc92

Apparemment, tu veux quelque chose qui fonctionne sur un tableur. Et en première colonne, tu as les nombres de 1 à ... disons 1000.
Tu peux ajouter une colonne, avec cette formule : =base(A1,2;32) et tu reproduis sur les lignes suivantes. Le 2 veut dire qu'on veut compter en base 2, donc uniquement avec des 0 et des 1, et le 32 veut dire qu'on veut 32 chiffres, donc on complète avec plein de 0 à gauche.
J'ai testé sur OpenOffice, j'imagine que ça marche aussi sur Excel.
Et ensuite, c'est visuel, tu constates qu'on n'a plus qu'à faire un substr().

Si tu n'as pas la 1ère colonne avec les n° de 1 à 1000, et si tu ne veux pas l'ajouter, si tu ne veux ajouter de colonne avec cette formule =base(...), ça se gère, c'est juste un peu plus compliqué.
12/11/2022, 11h52
mathieu

si on regarde les lignes 8 à 28 du traitements à 2 bits, on voit que ces les lignes se répètent dans le traitement à 3 bits avec un bit en plus dans la colonne 7 et ensuite un bit dans la colonne 6, etc.
donc je pense que vous pouvez faire cela avec une fonction récursive.
est ce que le langage de programmation donne la possibilité d'utiliser un cache ? ça permettrai d'avoir un algorithme simple et rapide en même temps.
12/11/2022, 12h52
rtg57

Bonjour à tous,

j'ai oublié de dire que cela ne se passe pas dans un tableur.
C'est juste une illustration 'visuelle' de ce que je cherche à obtenir avec un traitement de bits dans une variable informatique.

@mathieu:
Effectivement, on voit que les trames se répètent.
C'est d'ailleurs la raison pour laquelle je me suis fait une représentation visuelle dans un tableau...
C'était pour essayer de 'voir' s'il y a quelque chose de récurrent qui apparaît...

Mais bon... la constatation étant faite... quel algorithme permettrait d'atteindre ce fonctionnement ?
J'ai aussi pensé à une fonction récursive... mais la question ci-dessus reste d'actualité.

J'ai pensé aussi à faire des superpositions d'entier 32 bits indépendants genre:

................. 0010 0000
OU LOGIQUE 0001 0000
OU LOGIQUE 0000 1000
ce qui donne 0011 1000

et à gérer le décalage vers la droite selon une synchronisation finement opérée...
Mais cela reste complexe à traiter, surtout si l'on doit s'occuper d'un cas où il y a 16 bits à traiter du genre
0000 1111 1111 1111 1111 0000 0000 0000

pour arriver à
0000 0000 0000 0000 1111 1111 1111 1111

en passant par toutes les combinaisons

J'ai aussi traduit les valeurs binaires en valeurs décimale afin de chercher une suite logique dans la progression des nombres... Aucune logique apparente ! :(

Merci
12/11/2022, 15h28
tbc92

Même si tu ne passes par un tableur, la solution proposée est valable.
L'explication théorique derrière ça, c'est : écriture binaire

Avec une série de 0 et de 1, on peut traduire ça en un nombre entier. On ajoute 1 à cet entier ; et on refait la conversion inverse en 0 et 1 ; Et on obtient forcément un nouveau nombre.

j'ai essayé de faire ça en php et même si le temps de calcul est un peu plus rapide avec un cache, le cache prend beaucoup de place donc au final, la version sans cache aura peut-être plus de chance d'aller jusqu'au bout des calculs.
d'après votre dernier message, je suppose que vous vous limitez à 32 bits au total ?
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 $nb_bits = 8; $longeur = 26; $liste = liste_decal($nb_bits, $longeur); function liste_decal($nb_bits, $longeur) { $liste = []; if (0 === $nb_bits) { $liste[] = 0; } else { foreach (range($longeur - 1, $nb_bits - 1) as $puissance) { // pour $puissance allant de $longeur - 1 à $nb_bits - 1 foreach (liste_decal($nb_bits - 1, $puissance) as $base) { $liste[] = 2**$puissance + $base; // 2 puissance $puissance + $base } } } return $liste; } // FIN function liste_decal($nb_bits, $longeur)

12/11/2022, 15h47
rtg57

Merci tbc92,

mais j'ai du mal à faire le rapprochement entre:
- l'énumération des nombres binaires, c'est à dire l'allumage progressif de tous les bits, ce qui semble être le sujet du lien indiqué
- et mon problème qui consiste à trouver un moyen d'avoir par exemple, toutes les combinaisons de 16 bits allumés parmi 32 bits

Comme par exemple:
0000 1111 1111 1111 1111 0000 0000 0000

ou
0000 0111 1101 1111 1000 0001 0101 1001

ou
0000 0001 0110 1010 1001 1111 0010 1111

pour arriver à
0000 0000 0000 0000 1111 1111 1111 1111

Quelque chose m'échappe-t-il ?
12/11/2022, 16h40
mathieu

j'ai l'impression que WhiteCrow tient quelque chose qui consomme moins de ressources que ma fonction mais je n'ai pas tout compris.

Citation:

Envoyé par WhiteCrow

on ajoute à sa suite le nombre de bits indéplaçables on fait ce qu'on veut et on recommence.

quand j'ai lu "on fait ce qu'on veut", j'ai compris que je pouvais me lever et préparer le repas de ce soir mais ça ne fait pas avancer la question :mrgreen:

Citation:

Envoyé par WhiteCrow

Exemple : si on part de 1100 on aboutit successivement à 1010, 1001, 0110, 0101 et 0011 qui ne comporte plus de bits déplaçables.

là je n'ai pas compris le passage de "1001" à "0110".

Ce problème est un cas particulier du problème suivant:
>>> Lister tous les tuples de N valeurs entre xMin et xMax tel que la somme des valeurs fasse S.
Dans le cas des bits, on a xMin=0 et xMax=1. Et pour l'exemple demandé initialement, on a N=8 et S=2 ou 3.

Je présente l'algorithme récursive pour le problème général, pour être plus "pédagogique" (mais quand même en Python pour permettre aux gens, dont moi, de tester rapidement si ils veulent):

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
def iterate_on_sequences_with_sum(xMin, xMax, N, S, X=[]):
    """
    :param xMin: valeur minimale d'un élément de la séquence
    :param xMax: valeur maximale d'un élément de la séquence
    :param N: nb de valeurs à rajouter dans la séquence
    :param S: somme voulue des valeurs qui restent à rajouter
    :param X: séquence qu'on a construit jusque là, à laquelle il manque N valeurs
    """
    if N == 0: # Terminaison de la récursivité
        yield X # On a rajouté tous les éléments pour atteindre notre somme, on s'arrête.
        return
    # On appelle récursivement avec un nouvel élément.
    # Le nouvel élément à rajouter doit être entre xMin et xMax, mais doit être cohérent avec ce qu'il restera à rajouter
    xStart = max(xMin, S - (N - 1) * xMax) # On ne veut pas rajouter une valeur trop petite, qu'on ne pourrait pas conpenser même en rajoutant que xMax après
    xEnd = min(xMax, S - (N - 1) * xMin) # On ne veut pas rajouter une valeur trop grande, qu'on ne pourrait pas conpenser même en rajoutant que xMin après
    for x in range(xStart, xEnd + 1): # Pour toutes les valeurs possibles de l'élément à rajouter (entre xStart en xEnd inclus)
        # On ajoute l'élément et on actualise les paramètres pour l'appel récursif
        for Xresult in iterate_on_sequences_with_sum(xMin, xMax, N - 1, S - x, X + [x]):
            # On liste les séquences obtenues par appels récursifs
            yield Xresult

A noter que j'ai utilisé la notion d'itérateur parce que c'est ce qui est le plus approprié en Python, mais de manière générale, on peut directement "traiter" chaque séquence trouvée, ou les enregistrer dans une liste.

Résultat dans le cas des bits:

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
 
for X in iterate_on_sequences_with_sum(xMin=0, xMax=1, N=8, S=2):
    print(X)
 
[0, 0, 0, 0, 0, 0, 1, 1]
[0, 0, 0, 0, 0, 1, 0, 1]
[0, 0, 0, 0, 0, 1, 1, 0]
[0, 0, 0, 0, 1, 0, 0, 1]
[0, 0, 0, 0, 1, 0, 1, 0]
[0, 0, 0, 0, 1, 1, 0, 0]
[0, 0, 0, 1, 0, 0, 0, 1]
[0, 0, 0, 1, 0, 0, 1, 0]
[0, 0, 0, 1, 0, 1, 0, 0]
[0, 0, 0, 1, 1, 0, 0, 0]
[0, 0, 1, 0, 0, 0, 0, 1]
[0, 0, 1, 0, 0, 0, 1, 0]
[0, 0, 1, 0, 0, 1, 0, 0]
[0, 0, 1, 0, 1, 0, 0, 0]
[0, 0, 1, 1, 0, 0, 0, 0]
[0, 1, 0, 0, 0, 0, 0, 1]
[0, 1, 0, 0, 0, 0, 1, 0]
[0, 1, 0, 0, 0, 1, 0, 0]
[0, 1, 0, 0, 1, 0, 0, 0]
[0, 1, 0, 1, 0, 0, 0, 0]
[0, 1, 1, 0, 0, 0, 0, 0]
[1, 0, 0, 0, 0, 0, 0, 1]
[1, 0, 0, 0, 0, 0, 1, 0]
[1, 0, 0, 0, 0, 1, 0, 0]
[1, 0, 0, 0, 1, 0, 0, 0]
[1, 0, 0, 1, 0, 0, 0, 0]
[1, 0, 1, 0, 0, 0, 0, 0]
[1, 1, 0, 0, 0, 0, 0, 0]

12/11/2022, 18h30
Galet

Bonjour,
Autre proposition, pour rester sur la piste de WhiteCrow :
- Compter le nombre de bits à 1, pour calculer la valeur finale ((2^(n+1))-1
- Rechercher de Droite à gauche la première séquence 10
- La partie de Droite en incluant les 2 bits sera appelée Reste, la partie de Gauche : Base
- A ajouter à Base, toute les divisions de Reste par 2 (inversion des 2 bits : 10 => 01) jusqu'à atteindre 1
Effectuer cette fonction jusqu'à ce qu'il ne reste plus de séquence 10 (le nombre est alors identique à la valeur finale)
Un fonction récursive devrait être possible...
Bien l'bonjour,
12/11/2022, 20h14
tbc92

Ok, j'avais mal vu. Je pensais qu'on voulait toutes les combinaisons, je n'avais pas vu qu'on voulait toutes celles qui ont un nombre imposé de 0 et de 1.
12/11/2022, 22h55
WhiteCrow

Citation:

Envoyé par mathieu

j'ai l'impression que WhiteCrow tient quelque chose qui consomme moins de ressources que ma fonction mais je n'ai pas tout compris.
quand j'ai lu "on fait ce qu'on veut", j'ai compris que je pouvais me lever et préparer le repas de ce soir mais ça ne fait pas avancer la question :mrgreen:

là je n'ai pas compris le passage de "1001" à "0110".

Knuth l'expliquera bien mieux que moi mais :
«on fait ce qu'on veut» signifie simplement on fait ce qu'on a faire avec cette combinaison … peut importe le traitement qu'on a faire, on le fait.

Quand on est sur 1001, on commence à scanner à partir de la droite, le premier 1 ne peut être déplacé à droite, on continue le scan en gardant «1 bit non déplaçable», on passe le premier 0 et le second 0 avant d'arriver sur un 1 ; on le décale à droit et on rajoute 1 un à sa droite (car on a rencontré un bit non déplaçable) on arrive donc à 0110.

merci pour ces précisions, j'avais mal compris "on ajoute à sa suite le nombre de bits indéplaçables". j'ajoutais les chiffres comme dans une chaine de caractères alors que vous parliez d'une addition.

j'ai réessayé cette algorithme pour 3 bits à 1 sur une longueur de 6 et je n'y arrive pas :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 543210 <- numéro de bits 111000 110100 110010 110001 101010 <- pour écrire cette ligne, j'ai compté 1 bit indéplaçable (b0) ensuite j'ai déplacé b4 en b3 et j'ai additionné 1. donc à partir de là, j'ai loupé la combinaison 101100. et ensuite j'ai ça qui n'est peut être pas correct non plus 101001 100101 100011 010101 010011 001101 001011 000111

Je m'initie en ce moment au langage go, et c'était donc un bon exercice.
Au niveau manipulation des chaines, on peut certainement alléger tout ça, parce que ce n'est vraiment pas satisfaisant, mais ce n'était pas ma priorité.

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
 
import (
	"fmt"
)
func bitPremier(qt int, qn int) string {
	var ch string
	ch = ""
	for qqt := 0; qqt < qt-qn; qqt++ {
		ch = ch + "0"
	}
	for qqt := 0; qqt < qn; qqt++ {
		ch = ch + "1"
	}
	return ch
}
func bitSuivant(qch string, qt int, qn int) string {
	var ch string
	var nbZerosDroite int
	var queDesZerosADroite int
	queDesZerosADroite = 1
	for qqt := qt - 1; qqt > 0; qqt-- {
		if string(qch[qqt]) == "0" && queDesZerosADroite == 1 {
			nbZerosDroite++
		} else {
			queDesZerosADroite = 0
		}
		if string(qch[qqt-1]) == "0" && string(qch[qqt]) == "1" {
			ch = ""
			for qts := 0; qts < qqt-1; qts++ {
				ch = ch + string(qch[qts])
			}
			ch = ch + "10"
			for qts := 0; qts < nbZerosDroite; qts++ {
				ch = ch + "0"
			}
			for qts := len(ch); qts < qt; qts++ {
				ch = ch + "1"
			}
			return ch
		}
	}
	return ""
}
func main() {
	var tay int
	var nb1 int
	var ch string
	var nb int
	tay = 7
	nb1 = 3
	ch = bitPremier(tay, nb1)
	nb = 1
	for ch != "" {
		fmt.Println(ch, " rang= ", nb)
		ch = bitSuivant(ch, tay, nb1)
		nb++
	}
}

Résultat :

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
 
0000111  rang=  1
0001011  rang=  2
0001101  rang=  3
0001110  rang=  4
0010011  rang=  5
0010101  rang=  6
0010110  rang=  7
0011001  rang=  8
0011010  rang=  9
0011100  rang=  10
0100011  rang=  11
0100101  rang=  12
0100110  rang=  13
0101001  rang=  14
0101010  rang=  15
0101100  rang=  16
0110001  rang=  17
0110010  rang=  18
0110100  rang=  19
0111000  rang=  20
1000011  rang=  21
1000101  rang=  22
1000110  rang=  23
1001001  rang=  24
1001010  rang=  25
1001100  rang=  26
1010001  rang=  27
1010010  rang=  28
1010100  rang=  29
1011000  rang=  30
1100001  rang=  31
1100010  rang=  32
1100100  rang=  33
1101000  rang=  34
1110000  rang=  35

Explication de la fonction bitSuivant : je recherche la séquence "01" la plus à droite, je la remplace par "10", tous les 0 qui étaient tout à droite sont collés juste après ce "10"
Par exemple entre la ligne 7 et la ligne 8, on a 01 en colonnes 4 et 5 (on a aussi 01 en colonne 2 et 3, mais je prends celle la plus à droite) ; en ligne 7, la chaine se finissait par un seul 0, je colle donc un 6 en colonne 6, et le 1 restant est mis en colonne 7.

1 pièce(s) jointe(s)

Bonjour,

Pour avoir une solution naturellement adaptable je l'ai écrit sous forme recursive (ici en pascal) :
Code:

1 2 3 4 5 6 7 8 9 procedure Slip(bUp, bLen : Integer; V : Uint64 = 0); begin if bLen > 0 then while bUp >= bLen - 1 do begin Slip(bUP - 1, bLen - 1, V or (1 << bUp)); Dec(bUp); end else Ed.Append(Int2Bin(V) + ' '); end;
bUp est le rang du bit le plus élevé (7 dans les exemples montrés)
bLen est le nombre de bits qui doivent être à 1

On lance avec un Slip(bUp, bLen); (par exemple Slip(7, 3) pour le deuxième exemple, résultat quasi instantané).

Pièce jointe 628875
La partie la plus lente est la conversion en chaîne et l'affichage : infernale pour Slip(23, 12) mais moins de 2 secondes si pas d'affichage.

Salutations

1 pièce(s) jointe(s)

Bonsoir,

merci à tous pour votre aide à la résolution de mon problème.
Par vos différentes approches, vous m'avez permis de sortir de l'impasse dans laquelle j'errais depuis plusieurs jours.
En étudiant et rassemblant un peu toutes vos idées, j'ai fini par trouver l'algorithme qui produit le résultat attendu.

Pour ne pas restreindre les propositions, je n'avais pas indiqué que je préférais une solution linéaire plutôt qu'une solution récursive.
En effet, les données produites par cet algorithme, servent à d'autres mécanismes.
@Guesset: votre solution est très élégante, bravo.

Je programme en JAVA, qui met à disposition un objet BitSet.
Celui-ci permet de faire des opérations du des groupes de bits, et propose des outils intéressants pour ce faire.

Voici en gros le principe de fonctionnement que je vais tenter d'expliquer avec des mots.
Si l'on par sur l'exemple d'un travail sur 8 bits, avec une position de départ valant '00000111', voici les étapes pour passer

de '00000111'
à '11100000'

1) Je prépare un BitSet de travail que j'appelle bSetTravail, et dont la valeur sera initialisée '00000111', la combinaison initiale.

2) Ensuite je prépare un BitSet vigile que j'appelle bSetVigile, dont la valeur est calculée en fonction de la position initiale.
Dans notre cas, bSetVigile vaudra la combinaison finale '11100000',
et me permettra de détecter à moindre frais, l'atteinte de la fin du processus.

Je prépare aussi une variable appelée vigile_bit, qui sera initialisée dans notre cas, à 7, et qui indique le N° du dernier bit de la structure de travail.
Ce vigile détectera l'allumage du dernier bit le plus à gauche, ce qui indiquera qu'il faut faire un remaniement de bits.

Enfin, je positionne une variable index de bits, appelé idx_bit_a_commuter, qui visera le bit à commuter dans chaque étapes.
Elle sera initialisée à 2 dans notre cas, puisque c'est le bit N° 2 qui va être commuté à la première boucle.
'00000111'

3) Lancement de la boucle 'do-while' de calcul:
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 DO----------------------------------- Si( idx_bit_a_commuter == vigile_bit ) // Oui je commence d'entrée avec ce test { Si( bSetTravail == bSetVigile ) { break // Fin du processus, sortie de la boucle } // Arrivé ici signifie que le processus n'est pas terminé, il faut réorganiser les bits... // Là il faut regarder le tableau d'illustration pour bien suivre les étapes // Recherche en partant du bit à l'extrêmité gauche (index n° 7), et en scrutant vers la droite, du 1er bit à '0': idx_bit_a_commuter = bSetTravail.previousClearBit( idx_bit_a_commuter ); nb_bits_a_replacer = vigile_bit - idx_bit_a_commuter; // Nombre de bit qu'il faudra rallumer après décalage de réorganisation // Effacement de tous les bits situés à gauche de idx_bit_a_commuter bSetTravail.clear( idx_bit_a_commuter, nb_bits_travail ); // Recherche en partant de cet index, et en scrutant vers la droite, du 1er bit à '1': idx_bit_a_commuter = bSetTravail.previousSetBit( idx_bit_a_commuter ); bSetTravail.clear( idx_bit_a_commuter++ ); // Extinction du bit visé par idx_bit_a_commuter, indexage du bit à gauche de celui-ci bSetTravail.set( idx_bit_a_commuter ); // Allumage du bit visé par idx_bit_a_commuter // Boucle de replacement des bits initialement en bord gauche do { ++idx_bit_a_commuter; bSetTravail.set( idx_bit_a_commuter ); } while( --nb_bits_a_replacer > 0 ); } else // Décalage vers la gauche, du bit le plus à gauche, en vue d'atteindre le bord gauche { Mise à '0' du bit visé par idx_bit_a_commuter // '00000111' devient '00000011 Incrémentation de idx_bit_a_commuter // on se décale d'un cran vers la gauche... Mise à '1' du bit visé par idx_bit_a_commuter // '00000011' devient '00001011 } Incrémentation du compteur d'étape WHILE (true)-------------------------
Pièce jointe 628878

Voilà, j'ai essayé de ne pas trop mettre de langage JAVA, pour rester général.

Un test 'lourd' sur 32 bits avec 16 bits à '1' en initial, est résolu en 6 secondes après avoir parcouru environ 601 millions de combinaisons (Évidemment sans l'affichage des solutions).
Bon, ça ne veut trop rien dire, puisque cela dépend beaucoup de la machine, mais ce prototype me donne déjà entière satisfaction.

Encore merci à tous.