Erreur "Nom de type inconnu N" même si N est défini comme constant

Question

J'essaye de compiler le code ci-dessous, et j'obtiens deux erreurs sur la ligne qui lit void assert (n%64==0 && l%64 == 0);. Une erreur indique "nom de type inconnu 'n'" et l'autre dit "Expected ')" ". Aucun de ceux-ci n'a de sens pour moi, parce qu'il n'y a pas de parenthèses ouvertes qui ne sont pas fermées, et je définis 'n' ci-dessus avec la ligne const unsigned n = 2048;.

Je dois noter que ce code provient d'un article de 2013 de Daniela Frauchiger, Renato Renner et Matthias Troyer; qui peut être trouvé au https://arxiv.org/pdf/1311.4547.pdf. Il fait partie d'un extracteur aléatoire utilisé avec les générateurs de nombres aléatoires matériels. Le code n'est pas le mien, mais j'essaie de l'adapter à un projet sur lequel je travaille.

const unsigned n = 2048; // CHANGE to the number of input bits, must be multiple of 64 
const unsigned l = 1792; // CHANGE to the number of output bits, must be multiple of 64 

// the extraction function 
// parameters: 
// y: an output array of l bits stored as l/64 64−bit integers 
// m: a random matrix of l∗n bits , stored in l∗n/64 64−bit integers 
// x: an input array of n bits stores as n/64 64−bit integers 

void extract (uint64_t * y , uint64_t const * m, uint64_t const * x) 
{ 
    void assert (n%64==0 && l%64 == 0); 

    int ind=0; 
    // perform a matrix−vector multiplication by looping over all rows 
    // the outer loop over all words 
    for (int i = 0; i < l/64; ++i) { 
     y[i]=0; 
     // the inner loop over all bits in the word 
     for (unsigned j = 0; j < 64; ++j) { 
      uint64_t parity = m[ind++] & x[0]; 
      // performs a vector multiplication using bit operations 
      for (unsigned l = 1; l < n/64; ++l) 
      parity ^= m[ind++] & x[l]; 
      // finally obtain the bit parity 
      parity ^= parity >> 1; 
      parity ^= parity >> 2; 
      parity = (parity & 0x1111111111111111UL) * 0x1111111111111111UL; 
      // and set the j−th output bit of the i−th output word 
      y[i] |= ((parity >> 60) & 1) << j; 
     } 
    } 
} 

Je suis très nouveau à C, donc je me excuse si cela est une question stupide, mais je ne l'ai pas été en mesure de répondre à partir des réponses existantes.

Answer 1

void assert (n%64==0 && l%64 == 0); essaie de déclarer une fonction alled assert, mais elle est au mauvais endroit. Il suffit de supprimer le void et maintenant vous appelez la "fonction de débogage" assert pour vérifier que n et l rencontrent leurs contraintes requises.

void extract (uint64_t * y , uint64_t const * m, uint64_t const * x) 
{ 
    assert (n%64==0 && l%64 == 0); 
    ... 

Answer 2

Ajouter suivre les en-têtes sur le dessus de votre code:

#include <stdint.h> // uint64_t 
#include <assert.h> // assert 

changement

void assert (n%64==0 && l%64 == 0); 

Pour

assert (n%6==0 && l%64 == 0);