int main (void)
{
struct foo *fp = (struct foo *) malloc (2*sizeof (struct foo));
fbar(fp);
return 0;
}
void gwave(nec_complex& erv, nec_complex& ezv, nec_complex& erh,
nec_complex& ezh, nec_complex& eph, c_ground_wave& ground_wave) {
static nec_complex CONST4(0.0, em::impedance() / 2.0);
nec_float sppp, sppp2, cppp2, cppp, spp, spp2, cpp2, cpp;
nec_complex rk1, rk2, t1, t2, t3, t4, p1, rv;
nec_complex omr, w, f, q1, rh, v, g, xr1, xr2;
nec_complex x1, x2, x3, x4, x5, x6, x7;
sppp = ground_wave.zmh / ground_wave.r1;
sppp2 = sppp * sppp;
cppp2 = 1. - sppp2;
if (cppp2 < 1.0e-20)
cppp2 = 1.0e-20;
cppp = sqrt(cppp2);
spp = ground_wave.zph / ground_wave.r2;
spp2 = spp * spp;
cpp2 = 1. - spp2;
if (cpp2 < 1.0e-20)
cpp2 = 1.0e-20;
cpp = sqrt(cpp2);
rk1 = -two_pi_j() * ground_wave.r1;
rk2 = -two_pi_j() * ground_wave.r2;
t1 = 1. - ground_wave.u2 * cpp2;
t2 = sqrt(t1);
t3 = (1. - 1. / rk1) / rk1;
t4 = (1. - 1. / rk2) / rk2;
p1 = rk2 * ground_wave.u2 * t1 / (2. * cpp2);
rv = (spp - ground_wave.u * t2) / (spp + ground_wave.u * t2);
omr = 1. - rv;
w = 1. / omr;
w = nec_complex(4.0, 0.0) * p1 * w * w;
f = fbar(w);
q1 = rk2 * t1 / (2. * ground_wave.u2 * cpp2);
rh = (t2 - ground_wave.u * spp) / (t2 + ground_wave.u * spp);
v = 1. / (1. + rh);
v = nec_complex(4.0, 0.0) * q1 * v * v;
g = fbar(v);
xr1 = ground_wave.xx1 / ground_wave.r1;
xr2 = ground_wave.xx2 / ground_wave.r2;
x1 = cppp2 * xr1;
x2 = rv * cpp2 * xr2;
x3 = omr * cpp2 * f * xr2;
x4 = ground_wave.u * t2 * spp * 2. * xr2 / rk2;
x5 = xr1 * t3 * (1. - 3. * sppp2);
x6 = xr2 * t4 * (1. - 3. * spp2);
ezv = (x1 + x2 + x3 - x4 - x5 - x6) * (-CONST4);
x1 = sppp * cppp * xr1;
x2 = rv * spp * cpp * xr2;
x3 = cpp * omr * ground_wave.u * t2 * f * xr2;
x4 = spp * cpp * omr * xr2 / rk2;
x5 = 3. * sppp * cppp * t3 * xr1;
x6 = cpp * ground_wave.u * t2 * omr * xr2 / rk2 * .5;
x7 = 3. * spp * cpp * t4 * xr2;
erv = -(x1 + x2 - x3 + x4 - x5 + x6 - x7) * (-CONST4);
ezh = -(x1 - x2 + x3 - x4 - x5 - x6 + x7) * (-CONST4);
x1 = sppp2 * xr1;
x2 = rv * spp2 * xr2;
x4 = ground_wave.u2 * t1 * omr * f * xr2;
x5 = t3 * (1. - 3. * cppp2) * xr1;
x6 = t4 * (1. - 3. * cpp2) * (1. - ground_wave.u2 * (1. + rv) -
ground_wave.u2 * omr * f) * xr2;
x7 = ground_wave.u2 * cpp2 * omr * (1. - 1. / rk2) *
(f * (ground_wave.u2 * t1 - spp2 - 1. / rk2) + 1. / rk2) * xr2;
erh = (x1 - x2 - x4 - x5 + x6 + x7) * (-CONST4);
x1 = xr1;
x2 = rh * xr2;
x3 = (rh + 1.) * g * xr2;
x4 = t3 * xr1;
x5 = t4 * (1. - ground_wave.u2 * (1. + rv) -
ground_wave.u2 * omr * f) * xr2;
x6 = .5 * ground_wave.u2 * omr *
(f * (ground_wave.u2 * t1 - spp2 - 1. / rk2) + 1. / rk2) * xr2 / rk2;
eph = -(x1 - x2 + x3 - x4 + x5 + x6) * (-CONST4);
}
void
foo (int n)
{
float a[N+1];
float b[N];
float c[N];
float d[N];
int ia[N];
int ib[N];
int ic[N];
int i,j;
int diff = 0;
char cb[N];
char cc[N];
char image[N][N];
char block[N][N];
/* Vectorizable. */
diff = 0;
for (i = 0; i < N; i++) {
diff += (cb[i] - cc[i]);
}
ibar (&diff);
/* Vectorizable. */
diff = 0;
for (i = 0; i < N; i++) {
for (j = 0; j < N; j++) {
diff += (image[i][j] - block[i][j]);
}
}
ibar (&diff);
/* Vectorizable. */
for (i = 0; i < N; i++){
a[i] = b[i];
}
fbar (a);
/* Vectorizable. */
for (i = 0; i < N; i++){
a[i] = b[i] + c[i] + d[i];
}
fbar (a);
/* Strided access. Vectorizable on platforms that support load of strided
accesses (extract of even/odd vector elements). */
for (i = 0; i < N/2; i++){
a[i] = b[2*i+1] * c[2*i+1] - b[2*i] * c[2*i];
d[i] = b[2*i] * c[2*i+1] + b[2*i+1] * c[2*i];
}
fbar (a);
/* Vectorizable. */
for (i = 0; i < N; i++){
a[i] = b[i] + c[i];
d[i] = b[i] + c[i];
ia[i] = ib[i] + ic[i];
}
ibar (ia);
fbar (a);
fbar (d);
/* Not vetorizable yet (too conservative dependence test). */
for (i = 0; i < N; i++){
a[i] = b[i] + c[i];
a[i+1] = b[i] + c[i];
}
fbar (a);
}
