Manipulations de Bits et Octets

Version imprimable

14/12/2010, 14h54
Jiraiya-08

Manipulations de Bits et Octets

Bonjour,

Je dois faire des rotations de bits sur un tableau de 8 octets. Par exemple, si la rotation doit se faire sur 10 bits et qu'il faut décaler vers la droite, il faut que l'octet le plus à droite et les 2 premiers bits de l'octet à côté se retrouvent à gauche, et tout les autres octets doivent se décaler de 10 bits vers la droite. Le bit n°10 se retrouve à la position 0, le n°11 à la position 1, etc. Au final c'est une opération "RoR" quoi.

Comment faire ?

Merci beaucoup ;)
14/12/2010, 16h04
Alkhan

bonjour,

Pour le décalage de bits tu trouveras ton bonheur dans penser en java 2.
Regarde la section "Les opérateurs de décalage"
14/12/2010, 16h21
thelvin

Notons que, bien qu'il soit effectivement possible de le faire, grâce à ces opérateurs de décalage et aux opérateur booléens bit-à-bit...

C'est bel et bien très chiant à faire.
14/12/2010, 16h34
Jiraiya-08

Citation:

Envoyé par Alkhan

bonjour,

Pour le décalage de bits tu trouveras ton bonheur dans penser en java 2.
Regarde la section "Les opérateurs de décalage"

Merci pour ton aide :)

Cependant, la rotation doit se faire sour l'ensemble des bytes dans le tableau (rotation de 3 vers la gauche = les 3 bits de poid fort d'un octets deviennent les 3 bits de poids faible de l'octet qui est à sa gauche).

Encore merci.
14/12/2010, 17h37
Volune

Peut être que le java.math.BigInteger peut te simplifier la tâche.
Par exemple avec le constructeur public BigInteger(int signum, byte[] magnitude) et les méthodes de décalage de bits.
14/12/2010, 23h36
Jiraiya-08

Citation:

Envoyé par Volune

Peut être que le java.math.BigInteger peut te simplifier la tâche.
Par exemple avec le constructeur public BigInteger(int signum, byte[] magnitude) et les méthodes de décalage de bits.

Merci beaucoup Volune ! BigInteger m'a déjà beaucoup aidé :)

J'aurais encore une question:

Auriez-vous une méthode pour "aisément" récupérer les bits qui ont été décalés vers la gauche pour les remettre en début sans faire ça de cette manière:

- Application d'un masque pour récupérer les 5 derniers bits
- Division successives pour enlever tout les bits qui étaient à 0 dans le masque
- Report && nombre shifté.

Encore merci :D
15/12/2010, 00h40
thelvin

Je sais pas si ça te paraîtra bien plus simple, mais :

Citation:

Envoyé par Jiraiya-08

- Division successives pour enlever tout les bits qui étaient à 0 dans le masque

Tu peux utiliser un right-shift au lieu de ça :

Code:

b = (byte)(b >>> 5);

Ou plus simplement :

Code:

b >>>= 5;

bonjour,

si tu a besoin de faire beaucoup de traitement bit à bit je ferais une class qui vas permettre de faire cela de manière simple.

j'avais fait ceci (même si on peux faire plus performant avec les opérateur bit a bit):

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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
import java.util.LinkedList;
 
/**
 *
 * @author Amaridon Florent
 */
public class BitList extends LinkedList<Boolean>{
 
        /**
         * Charge un tableau de byte
         * @param bytes
         */
        public void loadByteArray(byte[] bytes) {
            this.clear();
            for (int x = bytes.length - 1; x >= 0; x--) {
                int b = bytes[x];
                for (int i = 0; i < 8; i++) {
                    int tmp = b & 0x01;
                    boolean bool = tmp > 0 ? true : false;
                    this.addLast(new Boolean(bool));
                    b = b >> 1;
                }
 
            }
        }
 
        /**
         * Effectue une rotation sur la gauche
         * @param start bit de poid le plus faible a prendre en compte dans la rotation
         * @param end nombre de bit a faire tourner
         */
        public void shiftLeft(int start, int end) {
            Boolean tmp = this.remove(start + end - 1);
            this.add(start, tmp);
        }
 
        /**
         * Effectue une rotation sur la droite
         * @param start start bit de poid le plus faible a prendre en compte dans la rotation
         * @param end nombre de bit a faire tourner
         */
        public void shiftRight(int start, int end) {
            Boolean tmp = this.remove(start);
            this.add(start + end - 1, tmp);
        }
 
        /**
         *
         * @param start index du bit de debut
         * @param end index du bit de fin
         * @param loops nombre de decalage
         */
        public void shiftRight(int start, int end, int loops) {
            for (int i = 0; i < loops; i++) {
                this.shiftRight(start, end);
            }
        }
 
        /**
         *
         * @param start index du bit de debut
         * @param end index du bit de fin
         * @param loops nombre de decalage
         */
        public void shiftLeft(int start, int end, int loops) {
            for (int i = 0; i < loops; i++) {
                this.shiftLeft(start, end);
            }
        }
 
        /**
         *
         * @param index index du bit a modifier
         * @param val valeur a lui donnée
         * @throws IndexOutOfBoundsException
         */
        public void setBit(int index, boolean val) throws IndexOutOfBoundsException{
            this.remove(index);
            this.add(index, new Boolean(val));
        }
 
        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder();
            for (int i = this.size() - 1; i >= 0; i--) {
                int tmp = this.get(i).equals(Boolean.TRUE) ? 1 : 0;
                if (((double) (i + 1) % 8 == 0.0) && (i != this.size() - 1)) {
                    sb.append(' ');
                }
                sb.append(tmp);
            }
            return sb.toString();
        }
 
        public String toString(int radix) {
            byte[] bytes = this.toByteArray();
            StringBuilder sb = new StringBuilder("[");
            for (byte b : bytes) {
                sb.append(Integer.toString(b, radix));
                sb.append(", ");
            }
            sb.replace(sb.length() - 2, sb.length(), "");
            sb.append("]");
 
            return sb.toString();
        }
 
        public byte[] toByteArray() {
            String[] splits = this.toString().split(" ");
            byte[] out = new byte[splits.length];
            for (int i = 0; i < splits.length; i++) {
                out[i] = Byte.valueOf(splits[i], 2);
            }
 
            return out;
        }
}