ошибка: недействительные операнды в двоичные^(есть «двойные» и «двойные») - я не пытаюсь использовать^как оператор питания

Question

Я искал ответ для этого, но не смог его найти. Я не пытаюсь использовать^как оператор мощности.

Вот моя проблема. Я пытаюсь воспроизвести перемежитель из стандарта цифрового телевидения (протокол физического уровня). Это проект для школы. Вот код, который я до сих пор в C:

#include <sys/io.h> 
#include <stdio.h> 
#include <stdlib.h> 
#include <errno.h> 
#include <sys/types.h> 
#include <sys/stat.h> 
#include <fcntl.h> 
#include <time.h> 
#include <unistd.h> 
#include <stdbool.h> 
#include <string.h> 
#include <complex.h> 
#include <math.h> 

int main() 
{ 
    int Mmax = 32768; 
    int Nr = log10(Mmax)/log10(2); 
    printf("Nr = %i \n",Nr); 

    int Lfm = 42; 

    int i,j,k,l; 

    // Create array R'i 
    unsigned char Rli[Mmax][Nr]; 
    for (i = 0; i < Mmax; i++) 
     memset(Rli[i], 0, sizeof(unsigned char)*(Nr)); 

    for (i = 0; i < Mmax; i++) 
    { 
     for(j = 1; j < Nr; j++) 
     { 
      if(i == 0 || i == 1) 
      { 
       Rli[i][j] = 0; 
      } 

      else if(i == 2) 
      { 
       Rli[i][j] = 0; 
       if(j == Nr - 2) 
        Rli[i][j] = 1; 
      } 

      else 
      { 
       Rli[i][j+1] = Rli[i-1][j]; 
      } 
     } 

     if(i > 2) 
     { 
      Rli[i][1] = (((Rli[i-1][14]^Rli[i-1][13])^Rli[i-1][12])^Rli[i-1][2]); 
     } 
     Rli[i][0] = 0; 
    } 

    // wire permutation for array R'i - creates array Ri 

    unsigned char Ri[Mmax][Nr]; 
    for (i = 0; i < Mmax; i++) 
     memset(Ri[i], 0, sizeof(unsigned char)*(Nr)); 

    for (i = 0; i < Mmax; i++) 
    { 
     Ri[i][1] = Rli[i][8]; //Rli[i][7]; 
     Ri[i][2] = Rli[i][9]; //Rli[i][8]; 
     Ri[i][3] = Rli[i][14]; //Rli[i][13]; 
     Ri[i][4] = Rli[i][4]; //Rli[i][3]; 
     Ri[i][5] = Rli[i][6]; //Rli[i][5]; 
     Ri[i][6] = Rli[i][13]; //Rli[i][12]; 
     Ri[i][7] = Rli[i][3]; //Rli[i][2]; 
     Ri[i][8] = Rli[i][2]; //Rli[i][1]; 
     Ri[i][9] = Rli[i][12]; //Rli[i][11]; 
     Ri[i][10] = Rli[i][5]; //Rli[i][4]; 
     Ri[i][11] = Rli[i][10]; //Rli[i][9]; 
     Ri[i][12] = Rli[i][11]; //Rli[i][10]; 
     Ri[i][13] = Rli[i][1]; //Rli[i][0]; 
     Ri[i][14] = Rli[i][7]; //Rli[i][6]; 
    } 

    // Offset generator Gk 

    int Gmax = floor(Lfm/2); 
    unsigned char Gk[Gmax][Nr]; 
    for (i = 0; i < Gmax; i++) 
     memset(Gk[i], 0, sizeof(unsigned char)*Nr-1); 

    for (k = 0; k < Gmax; k++) 
    { 
     for(j = 0; j < Nr; j++) 
     { 
      if(k == 0) 
      { 
       Gk[k][j] = 1; 
      } 

      else 
      { 
       Gk[k][j+1] = Gk[k-1][j]; 
      } 
     } 

     if(k > 0) 
     { 
      Gk[k][0] = (Gk[k-1][14]^Gk[k-1][13]); 
     } 

    } 

    // interleaving sequence 

    int Ndata = 26303; // numero de data 
    unsigned char Hl[Ndata]; 
    double H1[Ndata], H2[Ndata]; 
    memset(Hl, 0, sizeof(unsigned char)*Ndata); 
    memset(H1, 0, sizeof(double)*Ndata); 
    memset(H2, 0, sizeof(double)*Ndata); 

    int p,indice; 

    // loop from page 107 of the physical layer protocol. 
    for (i = 0; i < Lfm; i++) 
    { 
     for (k = 0; k < Mmax; k++) 
     { 
      p = 0; 
      for (j = 0; j < Nr; j++) // sum 
      { 
       if(j >= 0 && j <= Nr - 2) 
        H1[p] += Ri[k][j]*pow(2,j); 
       else if(j >= 0 && j <= Nr - 1) 
        { 
        indice = floor(i/2); 
        H2[p] += Gk[indice][j]*pow(2,j); 
        } 
      } 
    /*****/ Hl[p] = ((i % 2)*pow(2,Nr-1) + H1[p])^H2[p]; /*****/ 
      if (Hl[p] < Ndata) 
       p += 1; 
     } 
    } 

линия между/*****/в конце концов, приводит к ошибке при попытке компиляции.

freqint.c:146:43: error: invalid operands to binary^(have ‘double’ and ‘double’) 

     Hl[p] = ((i % 2)*pow(2,Nr-1) + H1[p])^H2[p]; 

Я хочу сделать операцию XOR там, но я не могу понять это правильно.

Я принимаю это от here.

последовательность чередования находится на нижней части страницы 107

Как написать свой код, чтобы избежать этого сообщения об ошибке и до сих пор в XOR?

Answer 1

Как указано в комментариях, оператор ^ не может использоваться на double, однако вам не нужно использовать double.

Вы используете две функции, которые возвращают double, а именно pow и floor.

Каждый раз, когда вы звоните pow, вы передаете 2 для базы. Повышение 2 до мощности может быть сделано намного эффективнее, если левый сдвиг значения 1 экспонентом.

Аналогично, каждый раз, когда вы вызываете floor, вы делите целочисленное значение на 2. Поскольку целочисленное деление автоматически отбрасывает оставшуюся часть деления (при условии, что вы работаете только с положительными значениями), вызов floor не купит вам ничего.

Измените все экземпляры pow(2,x) на (1 << x) и измените все экземпляры floor(x/2) на (x/2). Затем вы можете объявить H1 и H2 в виде массивов unsigned int, и вы сможете использовать оператор XOR ^.