Discussion :

[anouarista]

Bonjour à tous,

Je suis nouveau en programmation, est-ce que c'est possible de vous m'aider pour faire des fonctions pour un projet.
J'ai débuté mon projet et suis bloqué à une fonction voici la description:

Supposons, par exemple, que nous voulions transmettre la valeur 13 (en binaire : 1101). Nous effectuons alors le produit matriciel suivant :



voir photo en pièce jointe.


Le produit matriciel s’obtient en multipliant chaque ligne de la matrice génératrice par le vecteur de donnée à transmettre: - Faire un ET binaire entre chaque bit et faire un XOR entre les bits obtenus. Ainsi, en multipliant la 3e ligne de la matrice par la donnée (1101):
(1 0 1 1) * (1 1 0 1) = (1 & 1) ^ (0 & 1) ^ (1 & 0) ^ (1 & 1) = 1 ^ 0 ^ 0 ^ 1 = 0


#define MAT_GEN 0x0DB87421u //Matrice génératrice de Hamming
#define MAT_GEN_MASK 0xF0000000u //Masque de la matrice génératrice

uint hamm_produit_mat(uint matrice, uint data,uint nb_lignes, uint nb_cols, uint mask);

Calcule et retourne le produit matriciel de la matrice matrice par la donnée sur 4 bits data. Le résultat est un nombre sur 8 bits. Les paramètres nb_lignes, nb_colonnes et mask désignent respectivement le nombre de lignes, le nombre de colonnes et le masque à utiliser pour la matrice matrice.

Pour que le produit matriciel soit possible, il faut que le nombre minimal de bits de la donnée (data) soit inférieur ou égal au nombre de colonnes de la matrice. S’il n’est pas possible, retournez le code d’erreur : 0xFFFFFFFFu. Pour obtenir le nombre minimal de bits d’un nombre n: - 1 si le nombre est nul - (int)(log2(n)) + 1. //log2 est une fonction de <math.h>
Par exemple : hamm_produit_mat(MAT_GEN, 13u, 8, 4, MAT_GEN_MASK) doit nous retourner la valeur 85 (soit 0101 0101).

j'ai commencé par définir une macro-fonction qui isole et retourne la valeur de la ligne LN d’une matrice voici son prototype HAMM_MAT_LN(MAT, LN, NB_COL, NB_LN, MASK).

ma question est ce c'est possible de m'aider pour coder cette fonction uint hamm_produit_mat(uint matrice, uint data,uint nb_lignes, uint nb_cols, uint mask);

merci

[foetus]

C'est assez trivial À améliorer évidemment parce que c'est juste pour montrer comment faire, d'ailleurs tu n'expliques pas à quoi sert le masque de la matrice (j'ai fait un AND avec un NOT à vue de pif, ligne 67 ) :

Code :

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

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
118
119
120
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
 
 
#define MAT_GEN 0x0DB87421u      /* Matrice generatrice de Hamming */
#define MAT_GEN_MASK 0xF0000000u /* Masque de la matrice generatrice */
 
 
/* XXX Warning: macro uses nb_cols */
#define G_EXTRACT_BIT(X, COLUMN) ((X >> (nb_cols - COLUMN - 1)) & 1)
 
 
void debug_print_binary(unsigned long long value, unsigned short nb_digits, unsigned short pack_size, char* begin_str) {
    if (nb_digits > 0) {
        unsigned long long mask;
        unsigned short digit, display_count, tmp;
 
        mask = (((unsigned long long) 1) << (nb_digits - 1));
 
        printf("%s0x%llX (", begin_str, value);
 
        if (pack_size == 0) { pack_size = 8; }
 
        tmp           = (nb_digits % pack_size);
        display_count = 0;
 
/*      Left padding with zeros */
        if (tmp != 0) {
            tmp = (pack_size - tmp);
 
            for(digit=0; digit < tmp; ++digit, ++display_count) { printf("0"); }
        }
 
/*      Display first digit to avoid space in somes cases - (nb_digits % pack_size) == 0 */
        printf("%u", ((value & mask)? 1: 0));
 
        for(digit=1, ++display_count, mask /= 2; digit < nb_digits; ++digit, mask /= 2 /*or mask >>= 1*/, ++display_count) {
            if ((display_count % pack_size) != 0) {
                printf("%u", ((value & mask)? 1: 0));
            } else {
                printf(" %u", ((value & mask)? 1: 0));
            }
        }
 
        printf(")\n");
    }
}
 
 
unsigned int get_nb_bits(unsigned int value) {
    return ((value > 0)? (log2(value) + 1): 0);
}
 
 
unsigned int hamm_product_mat(unsigned int matrix,
                              unsigned int data,
                              unsigned int nb_lines,
                              unsigned int nb_cols,
                              unsigned int matrix_mask) {
 
    unsigned int line, column, value, final_value, line_val, col_mask;
 
    final_value = 0;
 
    for(line=0; line < nb_lines; ++line) {
        line_val = ((matrix & ~matrix_mask) >> ((nb_lines - line - 1) * 4)) & 0xF;
 
        col_mask = (1 << (nb_cols - 1));
 
        value    = (G_EXTRACT_BIT(line_val, 0) & G_EXTRACT_BIT(data, 0));
 
        printf("Next line (hex): %X\n(%u & %u)", line_val, G_EXTRACT_BIT(line_val, 0), G_EXTRACT_BIT(data, 0));
 
        for(column=1; column < nb_cols; ++column) {
            col_mask >>= 1; /* or col_mask /= 2 */
 
            value ^= (G_EXTRACT_BIT(line_val, column) & G_EXTRACT_BIT(data, column));
 
            printf(" ^ (%u & %u)", G_EXTRACT_BIT(line_val, column), G_EXTRACT_BIT(data, column));
        }
 
        final_value |= ((value & 1) << (nb_lines - line - 1));
 
        printf(" = %u\n\n", value);
    }
 
    return final_value;
}
 
 
int main()
{
    unsigned int data = 13;
 
    switch( get_nb_bits(data) ) {
    case 1: case 2: case 3: case 4:
        {
            unsigned int result, nb_digits;
 
            result    = hamm_product_mat(MAT_GEN, data, 8, 4, MAT_GEN_MASK);
            nb_digits = get_nb_bits(result);
 
            nb_digits = ((((nb_digits - 1) / 8) + 1) * 8); /* Next multiple of 8 */
 
            debug_print_binary(result, nb_digits, 8, "Result: ");
        }
        break;
 
    case 0:
        printf("XXX - error: data == 0\n");
        break;
 
    default:
        printf("XXX - error (0xFFFFFFFF): data width > 4\n");
    }
 
 
    return EXIT_SUCCESS;
}

Édit 1 : Amélioration de ma fonction d'affichage binaire pour avoir un affichage par paquets correct (le nombre est calé à droite et donc il faut bourrer de zéros à gauche pour avoir des paquets complets)

Édit 2 : "Pour obtenir le nombre minimal de bits d’un nombre n" effectivement il faut faire un log2. Mais dans ton cas , il semble que tu as juste à tester si le nombre est > 0 et < 16 (or 0X10) ... puisque ta matrice est créée avec des chiffres hexadécimaux.