Error: incomplete type is not allowed

EDN Admin · Mar 15, 2012

<div style="padding-bottom:0px; margin-bottom:0px; font-size:0.75em; line-height:1.5
Hi Everyone,

I found some error when I try to compile my below code (I use Visual Studio 2010),
this code generated message error like : Error: incomplete type is not allowed
for the replay and help, Im very appreciate. Thanks in advance

#include<stdio.h> 
#include<stdlib.h> 
#include<conio.h> 
#include<string.h> 
#include<math.h> 
#include<memory.h> 
#include<fstream> 
typedef unsigned char boolean; 
extern boolean rtIsNaN(float value); 
extern boolean rtIsInf(float value); 
extern float rtNaN; 
extern float rtInf; 
float diff_sig_data[10]; 
 
 
 
 
void b_conv(const float A_data[10], const int A_sizes[1], float C_data[10], int C_sizes[1]) 
{ 
int jC; 
int j; 
int jA1; 
int jA2; 
float s; 
static const int B[3] = { 0, -1, 1 }; 
 
 
C_sizes[0] = 10; 
for (jC = 0; jC < 10; jC++) 
{ 
j = jC + 2; 
if (3 < j + 1) 
<span style="white-space

re { 
jA1 = j - 2; 
} 
<span style="white-space

re else 
<span style="white-space

re { 
jA1 = 1; 
} 
 
 
if (10 < j) 
<span style="white-space

re { 
jA2 = 10; 
} 
<span style="white-space

re else 
<span style="white-space

re { 
jA2 = j; 
} 
 
 
s = 0.0; 
while (jA1 <= jA2) 
<span style="white-space

re { 
s += A_data[jA1 - 1] * (float)B[j - jA1]; 
jA1++; 
} 
 
 
C_data[jC] = s; 
} 
} 
 
 
void conv(const float A_data[10], const int A_sizes[1], float C_data[10],int C_sizes[1]) 
{ 
int jC; 
int j; 
int jA1; 
int jA2; 
float s; 
static const int B[3] = { 1, -1, 0 }; 
 
 
C_sizes[0] = 10; 
for (jC = 0; jC < 10; jC++) 
{ 
j = jC + 2; 
if (3 < j + 1) 
<span style="white-space

re { 
jA1 = j - 2; 
} 
<span style="white-space

re else 
<span style="white-space

re { 
jA1 = 1; 
} 
 
 
if (10 < j) 
<span style="white-space

re { 
jA2 = 10; 
} 
<span style="white-space

re else 
<span style="white-space

re { 
jA2 = j; 
} 
 
 
s = 0.0; 
while (jA1 <= jA2) 
<span style="white-space

re { 
s += A_data[jA1 - 1] * (float)B[j - jA1]; 
jA1++; 
} 
 
 
C_data[jC] = s; 
} 
} 
 
 
static float rt_powd_snf(float u0, float u1) 
{ 
float y; 
float d0; 
float d1; 
if (rtIsNaN(u0) || rtIsNaN(u1)) 
{ 
y = rtNaN; 
} 
else { 
d0 = fabs(u0); 
d1 = fabs(u1); 
if (rtIsInf(u1)) 
<span style="white-space

re { 
if (d0 == 1.0) 
<span style="white-space

re { 
y = rtNaN; 
} 
<span style="white-space

re else if (d0 > 1.0) 
<span style="white-space

re { 
if (u1 > 0.0) 
<span style="white-space

re { 
y = rtInf; 
} else 
<span style="white-space

re { 
y = 0.0; 
} 
} else if (u1 > 0.0) 
<span style="white-space

re { 
y = 0.0; 
} else 
<span style="white-space

re { 
y = rtInf; 
} 
} 
<span style="white-space

re else if (d1 == 0.0) 
<span style="white-space

re { 
y = 1.0; 
} 
<span style="white-space

re else if (d1 == 1.0) 
<span style="white-space

re { 
if (u1 > 0.0) 
<span style="white-space

re { 
y = u0; 
} else 
<span style="white-space

re { 
y = 1.0 / u0; 
} 
} 
<span style="white-space

re else if (u1 == 2.0) 
<span style="white-space

re { 
y = u0 * u0; 
} 
<span style="white-space

re else if ((u1 == 0.5) && (u0 >= 0.0)) 
<span style="white-space

re { 
y = sqrt(u0); 
} 
<span style="white-space

re else if ((u0 < 0.0) && (u1 > floor(u1))) 
<span style="white-space

re { 
y = rtNaN; 
} 
<span style="white-space

re else 
<span style="white-space

re { 
y = pow(u0, u1); 
} 
} 
 
 
return y; 
} 
 
 
void power(const float a_data[10], const int a_sizes[1], float y_data[10],int y_sizes[1]) 
{ 
int k; 
y_sizes[0] = 10; 
for (k = 0; k < 10; k++) 
{ 
y_data[k] = rt_powd_snf(a_data[k], 2.0); 
} 
} 
 
 
 
 
 
 
void aniso(float diff_sig_data[10], int diff_sig_sizes[1]) 
{ 
<span style="white-space

re const float b_sig[10]={10, 10, 11, 10, 9, 10, 13, 10, 10, 10}; 
<span style="white-space

re int t; 
<span style="white-space

re int nablaW_sizes; 
<span style="white-space

re float nablaW_data[10]; 
<span style="white-space

re int nablaE_sizes; 
<span style="white-space

re float nablaE_data[10]; 
<span style="white-space

re float b_nablaW_data[10]; 
<span style="white-space

re float b_nablaE_data[10]; 
<span style="white-space

re int tmp_sizes; 
<span style="white-space

re float tmp_data[10]; 
<span style="white-space

re int K=2; 
<span style="white-space

re int iteration=5; 
 
 
<span style="white-space

re diff_sig_sizes[0]=10; 
 
 
 
 
<span style="white-space

re memcpy((void *)&diff_sig_data[0], (void *)&b_sig[0], 10U * sizeof(float)); 
 
 
<span style="white-space

re for (t = 0; t < iteration; t++) //loop as long as number iteration 
<span style="white-space

re { 
<span style="white-space

re conv(diff_sig_data, diff_sig_sizes, nablaW_data, *(int (*)[1])&nablaW_sizes); //do the convolution to distinguish between edge end not 
<span style="white-space

re b_conv(diff_sig_data, diff_sig_sizes, nablaE_data, *(int (*)[1])&nablaE_sizes); 
 
 
 
 
nablaW_sizes = 10; 
for (nablaE_sizes = 0; nablaE_sizes < 10; nablaE_sizes++) // multiply with the coefficient 
<span style="white-space

re { 
b_nablaW_data[nablaE_sizes] = nablaW_data[nablaE_sizes] / K; 
b_nablaE_data[nablaE_sizes] = nablaE_data[nablaE_sizes] / K; 
} 
 
 
power(b_nablaW_data, *(int (*)[1])&nablaW_sizes, tmp_data, *(int (*)[1])&tmp_sizes); 
nablaE_sizes = 10; 
power(b_nablaE_data, *(int (*)[1])&nablaE_sizes, b_nablaW_data, *(int (*)[1])&tmp_sizes); 
 
 
<span style="white-space

re 
<span style="white-space

re diff_sig_sizes[0] = 10; 
for (nablaE_sizes = 0; nablaE_sizes < 10; nablaE_sizes++) 
<span style="white-space

re { 
diff_sig_data[nablaE_sizes] = diff_sig_data[nablaE_sizes] + 0.33333333333333331 * ((1.0 / (1.0 +tmp_data[nablaE_sizes]) * nablaW_data[nablaE_sizes] + 1.0 / (1.0 +b_nablaW_data[nablaE_sizes]) * nablaE_data[nablaE_sizes])+(diff_sig_data[0]-diff_sig_data[nablaE_sizes])); 
} 
<span style="white-space

re 
} 
} 
 
 
 
 
void main() 
{ 
<span style="white-space

re //float diff_sig_data[10]=[10 10 11 10 9 10 13 10 10 10]; 
 
 
<span style="white-space

re printf("aniso : nn%f",aniso()); 
 
 
return 0; 
} 
 
 
 
 
 
 
 

 

View the full article

Error: incomplete type is not allowed

EDN Admin

Well-known member