void fftwi_no_twiddle_9(const fftw_complex *input, fftw_complex *output,
int istride, int ostride)
{
fftw_real tmp5;
fftw_real tmp37;
fftw_real tmp57;
fftw_real tmp22;
fftw_real tmp56;
fftw_real tmp38;
fftw_real tmp10;
fftw_real tmp42;
fftw_real tmp66;
fftw_real tmp27;
fftw_real tmp45;
fftw_real tmp67;
fftw_real tmp15;
fftw_real tmp52;
fftw_real tmp69;
fftw_real tmp32;
fftw_real tmp49;
fftw_real tmp70;
ASSERT_ALIGNED_DOUBLE;
{
fftw_real tmp1;
fftw_real tmp2;
fftw_real tmp3;
fftw_real tmp4;
ASSERT_ALIGNED_DOUBLE;
tmp1 = c_re(input[0]);
tmp2 = c_re(input[3 * istride]);
tmp3 = c_re(input[6 * istride]);
tmp4 = tmp2 + tmp3;
tmp5 = tmp1 + tmp4;
tmp37 = tmp1 - (K500000000 * tmp4);
tmp57 = K866025403 * (tmp2 - tmp3);
}
{
fftw_real tmp18;
fftw_real tmp19;
fftw_real tmp20;
fftw_real tmp21;
ASSERT_ALIGNED_DOUBLE;
tmp18 = c_im(input[0]);
tmp19 = c_im(input[3 * istride]);
tmp20 = c_im(input[6 * istride]);
tmp21 = tmp19 + tmp20;
tmp22 = tmp18 + tmp21;
tmp56 = tmp18 - (K500000000 * tmp21);
tmp38 = K866025403 * (tmp20 - tmp19);
}
{
fftw_real tmp6;
fftw_real tmp23;
fftw_real tmp9;
fftw_real tmp44;
fftw_real tmp26;
fftw_real tmp41;
fftw_real tmp40;
fftw_real tmp43;
ASSERT_ALIGNED_DOUBLE;
tmp6 = c_re(input[istride]);
tmp23 = c_im(input[istride]);
{
fftw_real tmp7;
fftw_real tmp8;
fftw_real tmp24;
fftw_real tmp25;
ASSERT_ALIGNED_DOUBLE;
tmp7 = c_re(input[4 * istride]);
tmp8 = c_re(input[7 * istride]);
tmp9 = tmp7 + tmp8;
tmp44 = K866025403 * (tmp7 - tmp8);
tmp24 = c_im(input[4 * istride]);
tmp25 = c_im(input[7 * istride]);
tmp26 = tmp24 + tmp25;
tmp41 = K866025403 * (tmp25 - tmp24);
}
tmp10 = tmp6 + tmp9;
tmp40 = tmp6 - (K500000000 * tmp9);
tmp42 = tmp40 - tmp41;
tmp66 = tmp40 + tmp41;
tmp27 = tmp23 + tmp26;
tmp43 = tmp23 - (K500000000 * tmp26);
tmp45 = tmp43 - tmp44;
tmp67 = tmp44 + tmp43;
}
{
fftw_real tmp11;
fftw_real tmp28;
fftw_real tmp14;
fftw_real tmp48;
fftw_real tmp31;
fftw_real tmp51;
fftw_real tmp50;
fftw_real tmp47;
ASSERT_ALIGNED_DOUBLE;
tmp11 = c_re(input[2 * istride]);
tmp28 = c_im(input[2 * istride]);
{
fftw_real tmp12;
fftw_real tmp13;
fftw_real tmp29;
fftw_real tmp30;
ASSERT_ALIGNED_DOUBLE;
tmp12 = c_re(input[5 * istride]);
tmp13 = c_re(input[8 * istride]);
tmp14 = tmp12 + tmp13;
tmp48 = K866025403 * (tmp12 - tmp13);
tmp29 = c_im(input[5 * istride]);
tmp30 = c_im(input[8 * istride]);
tmp31 = tmp29 + tmp30;
tmp51 = K866025403 * (tmp30 - tmp29);
}
tmp15 = tmp11 + tmp14;
tmp50 = tmp11 - (K500000000 * tmp14);
tmp52 = tmp50 - tmp51;
tmp69 = tmp50 + tmp51;
tmp32 = tmp28 + tmp31;
tmp47 = tmp28 - (K500000000 * tmp31);
tmp49 = tmp47 - tmp48;
tmp70 = tmp48 + tmp47;
}
{
fftw_real tmp36;
fftw_real tmp16;
fftw_real tmp35;
fftw_real tmp17;
fftw_real tmp33;
fftw_real tmp34;
ASSERT_ALIGNED_DOUBLE;
tmp36 = K866025403 * (tmp32 - tmp27);
tmp16 = tmp10 + tmp15;
tmp35 = tmp5 - (K500000000 * tmp16);
c_re(output[0]) = tmp5 + tmp16;
c_re(output[3 * ostride]) = tmp35 + tmp36;
c_re(output[6 * ostride]) = tmp35 - tmp36;
tmp17 = K866025403 * (tmp10 - tmp15);
tmp33 = tmp27 + tmp32;
tmp34 = tmp22 - (K500000000 * tmp33);
c_im(output[3 * ostride]) = tmp17 + tmp34;
c_im(output[6 * ostride]) = tmp34 - tmp17;
c_im(output[0]) = tmp22 + tmp33;
}
{
fftw_real tmp39;
fftw_real tmp61;
fftw_real tmp64;
fftw_real tmp58;
fftw_real tmp54;
fftw_real tmp55;
fftw_real tmp63;
fftw_real tmp62;
ASSERT_ALIGNED_DOUBLE;
{
fftw_real tmp59;
fftw_real tmp60;
fftw_real tmp46;
fftw_real tmp53;
ASSERT_ALIGNED_DOUBLE;
tmp39 = tmp37 - tmp38;
tmp59 = (K173648177 * tmp45) + (K984807753 * tmp42);
tmp60 = (K342020143 * tmp52) - (K939692620 * tmp49);
tmp61 = tmp59 + tmp60;
tmp64 = K866025403 * (tmp60 - tmp59);
tmp58 = tmp56 - tmp57;
tmp46 = (K173648177 * tmp42) - (K984807753 * tmp45);
tmp53 = (K342020143 * tmp49) + (K939692620 * tmp52);
tmp54 = tmp46 - tmp53;
tmp55 = K866025403 * (tmp46 + tmp53);
}
c_re(output[2 * ostride]) = tmp39 + tmp54;
tmp63 = tmp39 - (K500000000 * tmp54);
c_re(output[8 * ostride]) = tmp63 - tmp64;
c_re(output[5 * ostride]) = tmp63 + tmp64;
c_im(output[2 * ostride]) = tmp58 + tmp61;
tmp62 = tmp58 - (K500000000 * tmp61);
c_im(output[5 * ostride]) = tmp55 + tmp62;
c_im(output[8 * ostride]) = tmp62 - tmp55;
}
{
fftw_real tmp65;
fftw_real tmp77;
fftw_real tmp80;
fftw_real tmp74;
fftw_real tmp72;
fftw_real tmp73;
fftw_real tmp79;
fftw_real tmp78;
ASSERT_ALIGNED_DOUBLE;
{
fftw_real tmp75;
fftw_real tmp76;
fftw_real tmp68;
fftw_real tmp71;
ASSERT_ALIGNED_DOUBLE;
tmp65 = tmp37 + tmp38;
tmp75 = (K766044443 * tmp67) + (K642787609 * tmp66);
tmp76 = (K173648177 * tmp70) + (K984807753 * tmp69);
tmp77 = tmp75 + tmp76;
tmp80 = K866025403 * (tmp76 - tmp75);
tmp74 = tmp57 + tmp56;
tmp68 = (K766044443 * tmp66) - (K642787609 * tmp67);
tmp71 = (K173648177 * tmp69) - (K984807753 * tmp70);
tmp72 = tmp68 + tmp71;
tmp73 = K866025403 * (tmp68 - tmp71);
}
c_re(output[ostride]) = tmp65 + tmp72;
tmp79 = tmp65 - (K500000000 * tmp72);
c_re(output[7 * ostride]) = tmp79 - tmp80;
c_re(output[4 * ostride]) = tmp79 + tmp80;
c_im(output[ostride]) = tmp74 + tmp77;
tmp78 = tmp74 - (K500000000 * tmp77);
c_im(output[4 * ostride]) = tmp73 + tmp78;
c_im(output[7 * ostride]) = tmp78 - tmp73;
}
}
void fftw_hc2hc_forward_7(fftw_real *A, const fftw_complex *W,
int iostride, int m, int dist)
{
int i;
fftw_real *X;
fftw_real *Y;
X = A;
Y = A + (7 * iostride);
{
fftw_real tmp86;
fftw_real tmp84;
fftw_real tmp88;
fftw_real tmp78;
fftw_real tmp85;
fftw_real tmp81;
fftw_real tmp87;
fftw_real tmp82;
fftw_real tmp83;
ASSERT_ALIGNED_DOUBLE;
tmp86 = X[0];
tmp82 = X[3 * iostride];
tmp83 = X[4 * iostride];
tmp84 = tmp82 - tmp83;
tmp88 = tmp82 + tmp83;
{
fftw_real tmp76;
fftw_real tmp77;
fftw_real tmp79;
fftw_real tmp80;
ASSERT_ALIGNED_DOUBLE;
tmp76 = X[2 * iostride];
tmp77 = X[5 * iostride];
tmp78 = tmp76 - tmp77;
tmp85 = tmp76 + tmp77;
tmp79 = X[iostride];
tmp80 = X[6 * iostride];
tmp81 = tmp79 - tmp80;
tmp87 = tmp79 + tmp80;
}
Y[-3 * iostride] =
(K781831482 * tmp78) - (K433883739 * tmp81) -
(K974927912 * tmp84);
Y[-iostride] =
-((K974927912 * tmp78) + (K433883739 * tmp84) +
(K781831482 * tmp81));
Y[-2 * iostride] =
(K433883739 * tmp78) + (K781831482 * tmp84) -
(K974927912 * tmp81);
X[2 * iostride] =
(K623489801 * tmp88) + tmp86 - (K222520933 * tmp87) -
(K900968867 * tmp85);
X[iostride] =
(K623489801 * tmp87) + tmp86 - (K900968867 * tmp88) -
(K222520933 * tmp85);
X[3 * iostride] =
(K623489801 * tmp85) + tmp86 - (K900968867 * tmp87) -
(K222520933 * tmp88);
X[0] = tmp85 + tmp88 + tmp87 + tmp86;
}
X = X + dist;
Y = Y - dist;
for (i = 2; i < m; i = i + 2, X = X + dist, Y = Y - dist, W = W + 6) {
fftw_real tmp14;
fftw_real tmp66;
fftw_real tmp25;
fftw_real tmp68;
fftw_real tmp51;
fftw_real tmp63;
fftw_real tmp36;
fftw_real tmp69;
fftw_real tmp57;
fftw_real tmp64;
fftw_real tmp47;
fftw_real tmp70;
fftw_real tmp54;
fftw_real tmp65;
ASSERT_ALIGNED_DOUBLE;
tmp14 = X[0];
tmp66 = Y[-6 * iostride];
{
fftw_real tmp19;
fftw_real tmp49;
fftw_real tmp24;
fftw_real tmp50;
ASSERT_ALIGNED_DOUBLE;
{
fftw_real tmp16;
fftw_real tmp18;
fftw_real tmp15;
fftw_real tmp17;
ASSERT_ALIGNED_DOUBLE;
tmp16 = X[iostride];
tmp18 = Y[-5 * iostride];
tmp15 = c_re(W[0]);
tmp17 = c_im(W[0]);
tmp19 = (tmp15 * tmp16) - (tmp17 * tmp18);
tmp49 = (tmp17 * tmp16) + (tmp15 * tmp18);
}
{
fftw_real tmp21;
fftw_real tmp23;
fftw_real tmp20;
fftw_real tmp22;
ASSERT_ALIGNED_DOUBLE;
tmp21 = X[6 * iostride];
tmp23 = Y[0];
tmp20 = c_re(W[5]);
tmp22 = c_im(W[5]);
tmp24 = (tmp20 * tmp21) - (tmp22 * tmp23);
tmp50 = (tmp22 * tmp21) + (tmp20 * tmp23);
}
tmp25 = tmp19 + tmp24;
tmp68 = tmp24 - tmp19;
tmp51 = tmp49 - tmp50;
tmp63 = tmp49 + tmp50;
}
{
fftw_real tmp30;
fftw_real tmp55;
fftw_real tmp35;
fftw_real tmp56;
ASSERT_ALIGNED_DOUBLE;
{
fftw_real tmp27;
fftw_real tmp29;
fftw_real tmp26;
fftw_real tmp28;
ASSERT_ALIGNED_DOUBLE;
tmp27 = X[2 * iostride];
tmp29 = Y[-4 * iostride];
tmp26 = c_re(W[1]);
tmp28 = c_im(W[1]);
tmp30 = (tmp26 * tmp27) - (tmp28 * tmp29);
tmp55 = (tmp28 * tmp27) + (tmp26 * tmp29);
}
{
fftw_real tmp32;
fftw_real tmp34;
fftw_real tmp31;
fftw_real tmp33;
ASSERT_ALIGNED_DOUBLE;
tmp32 = X[5 * iostride];
tmp34 = Y[-iostride];
tmp31 = c_re(W[4]);
tmp33 = c_im(W[4]);
tmp35 = (tmp31 * tmp32) - (tmp33 * tmp34);
tmp56 = (tmp33 * tmp32) + (tmp31 * tmp34);
}
tmp36 = tmp30 + tmp35;
tmp69 = tmp35 - tmp30;
tmp57 = tmp55 - tmp56;
tmp64 = tmp55 + tmp56;
}
{
fftw_real tmp41;
fftw_real tmp52;
fftw_real tmp46;
fftw_real tmp53;
ASSERT_ALIGNED_DOUBLE;
{
fftw_real tmp38;
fftw_real tmp40;
fftw_real tmp37;
fftw_real tmp39;
ASSERT_ALIGNED_DOUBLE;
tmp38 = X[3 * iostride];
tmp40 = Y[-3 * iostride];
tmp37 = c_re(W[2]);
tmp39 = c_im(W[2]);
tmp41 = (tmp37 * tmp38) - (tmp39 * tmp40);
tmp52 = (tmp39 * tmp38) + (tmp37 * tmp40);
}
{
fftw_real tmp43;
fftw_real tmp45;
fftw_real tmp42;
fftw_real tmp44;
ASSERT_ALIGNED_DOUBLE;
tmp43 = X[4 * iostride];
tmp45 = Y[-2 * iostride];
tmp42 = c_re(W[3]);
tmp44 = c_im(W[3]);
tmp46 = (tmp42 * tmp43) - (tmp44 * tmp45);
tmp53 = (tmp44 * tmp43) + (tmp42 * tmp45);
}
tmp47 = tmp41 + tmp46;
tmp70 = tmp46 - tmp41;
tmp54 = tmp52 - tmp53;
tmp65 = tmp52 + tmp53;
}
{
fftw_real tmp60;
fftw_real tmp59;
fftw_real tmp73;
fftw_real tmp72;
ASSERT_ALIGNED_DOUBLE;
X[0] = tmp14 + tmp25 + tmp36 + tmp47;
tmp60 =
(K781831482 * tmp51) + (K974927912 * tmp57) +
(K433883739 * tmp54);
tmp59 =
tmp14 + (K623489801 * tmp25) - (K900968867 * tmp47) -
(K222520933 * tmp36);
Y[-6 * iostride] = tmp59 - tmp60;
X[iostride] = tmp59 + tmp60;
{
fftw_real tmp62;
fftw_real tmp61;
fftw_real tmp58;
fftw_real tmp48;
ASSERT_ALIGNED_DOUBLE;
tmp62 =
(K433883739 * tmp51) + (K974927912 * tmp54) -
(K781831482 * tmp57);
tmp61 =
tmp14 + (K623489801 * tmp36) -
(K222520933 * tmp47) - (K900968867 * tmp25);
Y[-4 * iostride] = tmp61 - tmp62;
X[3 * iostride] = tmp61 + tmp62;
tmp58 =
(K974927912 * tmp51) - (K781831482 * tmp54) -
(K433883739 * tmp57);
tmp48 =
tmp14 + (K623489801 * tmp47) -
(K900968867 * tmp36) - (K222520933 * tmp25);
Y[-5 * iostride] = tmp48 - tmp58;
X[2 * iostride] = tmp48 + tmp58;
}
Y[0] = tmp63 + tmp64 + tmp65 + tmp66;
tmp73 =
(K974927912 * tmp68) - (K781831482 * tmp70) -
(K433883739 * tmp69);
tmp72 =
(K623489801 * tmp65) + tmp66 - (K900968867 * tmp64) -
(K222520933 * tmp63);
X[5 * iostride] = -(tmp72 - tmp73);
Y[-2 * iostride] = tmp73 + tmp72;
{
fftw_real tmp75;
fftw_real tmp74;
fftw_real tmp71;
fftw_real tmp67;
ASSERT_ALIGNED_DOUBLE;
tmp75 =
(K433883739 * tmp68) + (K974927912 * tmp70) -
(K781831482 * tmp69);
tmp74 =
(K623489801 * tmp64) + tmp66 -
(K222520933 * tmp65) - (K900968867 * tmp63);
X[4 * iostride] = -(tmp74 - tmp75);
Y[-3 * iostride] = tmp75 + tmp74;
tmp71 =
(K781831482 * tmp68) + (K974927912 * tmp69) +
(K433883739 * tmp70);
tmp67 =
(K623489801 * tmp63) + tmp66 -
(K900968867 * tmp65) - (K222520933 * tmp64);
X[6 * iostride] = -(tmp67 - tmp71);
Y[-iostride] = tmp71 + tmp67;
}
}
}
if (i == m) {
fftw_real tmp1;
fftw_real tmp10;
fftw_real tmp11;
fftw_real tmp4;
fftw_real tmp12;
fftw_real tmp7;
fftw_real tmp13;
fftw_real tmp8;
fftw_real tmp9;
ASSERT_ALIGNED_DOUBLE;
tmp1 = X[0];
tmp8 = X[2 * iostride];
tmp9 = X[5 * iostride];
tmp10 = tmp8 - tmp9;
tmp11 = tmp8 + tmp9;
{
fftw_real tmp2;
fftw_real tmp3;
fftw_real tmp5;
fftw_real tmp6;
ASSERT_ALIGNED_DOUBLE;
tmp2 = X[3 * iostride];
tmp3 = X[4 * iostride];
tmp4 = tmp2 - tmp3;
tmp12 = tmp2 + tmp3;
tmp5 = X[iostride];
tmp6 = X[6 * iostride];
tmp7 = tmp5 - tmp6;
tmp13 = tmp5 + tmp6;
}
Y[0] =
-((K781831482 * tmp11) + (K974927912 * tmp12) +
(K433883739 * tmp13));
Y[-iostride] =
(K781831482 * tmp12) - (K974927912 * tmp13) -
(K433883739 * tmp11);
Y[-2 * iostride] =
(K974927912 * tmp11) - (K781831482 * tmp13) -
(K433883739 * tmp12);
X[iostride] =
tmp1 + (K222520933 * tmp7) - (K623489801 * tmp4) -
(K900968867 * tmp10);
X[3 * iostride] = tmp1 + tmp10 - (tmp4 + tmp7);
X[2 * iostride] =
tmp1 + (K900968867 * tmp4) - (K623489801 * tmp7) -
(K222520933 * tmp10);
X[0] =
tmp1 + (K623489801 * tmp10) + (K222520933 * tmp4) +
(K900968867 * tmp7);
}
}
void fftw_twiddle_9(fftw_complex *A, const fftw_complex *W, int iostride, int m, int dist)
{
int i;
fftw_complex *inout;
inout = A;
for (i = m; i > 0; i = i - 1, inout = inout + dist, W = W + 8) {
fftw_real tmp1;
fftw_real tmp99;
fftw_real tmp52;
fftw_real tmp98;
fftw_real tmp105;
fftw_real tmp104;
fftw_real tmp12;
fftw_real tmp49;
fftw_real tmp47;
fftw_real tmp69;
fftw_real tmp86;
fftw_real tmp95;
fftw_real tmp74;
fftw_real tmp85;
fftw_real tmp30;
fftw_real tmp58;
fftw_real tmp82;
fftw_real tmp94;
fftw_real tmp63;
fftw_real tmp83;
ASSERT_ALIGNED_DOUBLE;
{
fftw_real tmp6;
fftw_real tmp50;
fftw_real tmp11;
fftw_real tmp51;
ASSERT_ALIGNED_DOUBLE;
tmp1 = c_re(inout[0]);
tmp99 = c_im(inout[0]);
{
fftw_real tmp3;
fftw_real tmp5;
fftw_real tmp2;
fftw_real tmp4;
ASSERT_ALIGNED_DOUBLE;
tmp3 = c_re(inout[3 * iostride]);
tmp5 = c_im(inout[3 * iostride]);
tmp2 = c_re(W[2]);
tmp4 = c_im(W[2]);
tmp6 = (tmp2 * tmp3) - (tmp4 * tmp5);
tmp50 = (tmp4 * tmp3) + (tmp2 * tmp5);
}
{
fftw_real tmp8;
fftw_real tmp10;
fftw_real tmp7;
fftw_real tmp9;
ASSERT_ALIGNED_DOUBLE;
tmp8 = c_re(inout[6 * iostride]);
tmp10 = c_im(inout[6 * iostride]);
tmp7 = c_re(W[5]);
tmp9 = c_im(W[5]);
tmp11 = (tmp7 * tmp8) - (tmp9 * tmp10);
tmp51 = (tmp9 * tmp8) + (tmp7 * tmp10);
}
tmp52 = K866025403 * (tmp50 - tmp51);
tmp98 = tmp50 + tmp51;
tmp105 = tmp99 - (K500000000 * tmp98);
tmp104 = K866025403 * (tmp11 - tmp6);
tmp12 = tmp6 + tmp11;
tmp49 = tmp1 - (K500000000 * tmp12);
}
{
fftw_real tmp35;
fftw_real tmp71;
fftw_real tmp40;
fftw_real tmp66;
fftw_real tmp45;
fftw_real tmp67;
fftw_real tmp46;
fftw_real tmp72;
ASSERT_ALIGNED_DOUBLE;
{
fftw_real tmp32;
fftw_real tmp34;
fftw_real tmp31;
fftw_real tmp33;
ASSERT_ALIGNED_DOUBLE;
tmp32 = c_re(inout[2 * iostride]);
tmp34 = c_im(inout[2 * iostride]);
tmp31 = c_re(W[1]);
tmp33 = c_im(W[1]);
tmp35 = (tmp31 * tmp32) - (tmp33 * tmp34);
tmp71 = (tmp33 * tmp32) + (tmp31 * tmp34);
}
{
fftw_real tmp37;
fftw_real tmp39;
fftw_real tmp36;
fftw_real tmp38;
ASSERT_ALIGNED_DOUBLE;
tmp37 = c_re(inout[5 * iostride]);
tmp39 = c_im(inout[5 * iostride]);
tmp36 = c_re(W[4]);
tmp38 = c_im(W[4]);
tmp40 = (tmp36 * tmp37) - (tmp38 * tmp39);
tmp66 = (tmp38 * tmp37) + (tmp36 * tmp39);
}
{
fftw_real tmp42;
fftw_real tmp44;
fftw_real tmp41;
fftw_real tmp43;
ASSERT_ALIGNED_DOUBLE;
tmp42 = c_re(inout[8 * iostride]);
tmp44 = c_im(inout[8 * iostride]);
tmp41 = c_re(W[7]);
tmp43 = c_im(W[7]);
tmp45 = (tmp41 * tmp42) - (tmp43 * tmp44);
tmp67 = (tmp43 * tmp42) + (tmp41 * tmp44);
}
tmp46 = tmp40 + tmp45;
tmp72 = tmp66 + tmp67;
{
fftw_real tmp65;
fftw_real tmp68;
fftw_real tmp70;
fftw_real tmp73;
ASSERT_ALIGNED_DOUBLE;
tmp47 = tmp35 + tmp46;
tmp65 = tmp35 - (K500000000 * tmp46);
tmp68 = K866025403 * (tmp66 - tmp67);
tmp69 = tmp65 + tmp68;
tmp86 = tmp65 - tmp68;
tmp95 = tmp71 + tmp72;
tmp70 = K866025403 * (tmp45 - tmp40);
tmp73 = tmp71 - (K500000000 * tmp72);
tmp74 = tmp70 + tmp73;
tmp85 = tmp73 - tmp70;
}
}
{
fftw_real tmp18;
fftw_real tmp60;
fftw_real tmp23;
fftw_real tmp55;
fftw_real tmp28;
fftw_real tmp56;
fftw_real tmp29;
fftw_real tmp61;
ASSERT_ALIGNED_DOUBLE;
{
fftw_real tmp15;
fftw_real tmp17;
fftw_real tmp14;
fftw_real tmp16;
ASSERT_ALIGNED_DOUBLE;
tmp15 = c_re(inout[iostride]);
tmp17 = c_im(inout[iostride]);
tmp14 = c_re(W[0]);
tmp16 = c_im(W[0]);
tmp18 = (tmp14 * tmp15) - (tmp16 * tmp17);
tmp60 = (tmp16 * tmp15) + (tmp14 * tmp17);
}
{
fftw_real tmp20;
fftw_real tmp22;
fftw_real tmp19;
fftw_real tmp21;
ASSERT_ALIGNED_DOUBLE;
tmp20 = c_re(inout[4 * iostride]);
tmp22 = c_im(inout[4 * iostride]);
tmp19 = c_re(W[3]);
tmp21 = c_im(W[3]);
tmp23 = (tmp19 * tmp20) - (tmp21 * tmp22);
tmp55 = (tmp21 * tmp20) + (tmp19 * tmp22);
}
{
fftw_real tmp25;
fftw_real tmp27;
fftw_real tmp24;
fftw_real tmp26;
ASSERT_ALIGNED_DOUBLE;
tmp25 = c_re(inout[7 * iostride]);
tmp27 = c_im(inout[7 * iostride]);
tmp24 = c_re(W[6]);
tmp26 = c_im(W[6]);
tmp28 = (tmp24 * tmp25) - (tmp26 * tmp27);
tmp56 = (tmp26 * tmp25) + (tmp24 * tmp27);
}
tmp29 = tmp23 + tmp28;
tmp61 = tmp55 + tmp56;
{
fftw_real tmp54;
fftw_real tmp57;
fftw_real tmp59;
fftw_real tmp62;
ASSERT_ALIGNED_DOUBLE;
tmp30 = tmp18 + tmp29;
tmp54 = tmp18 - (K500000000 * tmp29);
tmp57 = K866025403 * (tmp55 - tmp56);
tmp58 = tmp54 + tmp57;
tmp82 = tmp54 - tmp57;
tmp94 = tmp60 + tmp61;
tmp59 = K866025403 * (tmp28 - tmp23);
tmp62 = tmp60 - (K500000000 * tmp61);
tmp63 = tmp59 + tmp62;
tmp83 = tmp62 - tmp59;
}
}
{
fftw_real tmp96;
fftw_real tmp13;
fftw_real tmp48;
fftw_real tmp93;
ASSERT_ALIGNED_DOUBLE;
tmp96 = K866025403 * (tmp94 - tmp95);
tmp13 = tmp1 + tmp12;
tmp48 = tmp30 + tmp47;
tmp93 = tmp13 - (K500000000 * tmp48);
c_re(inout[0]) = tmp13 + tmp48;
c_re(inout[3 * iostride]) = tmp93 + tmp96;
c_re(inout[6 * iostride]) = tmp93 - tmp96;
}
{
fftw_real tmp101;
fftw_real tmp97;
fftw_real tmp100;
fftw_real tmp102;
ASSERT_ALIGNED_DOUBLE;
tmp101 = K866025403 * (tmp47 - tmp30);
tmp97 = tmp94 + tmp95;
tmp100 = tmp98 + tmp99;
tmp102 = tmp100 - (K500000000 * tmp97);
c_im(inout[0]) = tmp97 + tmp100;
c_im(inout[6 * iostride]) = tmp102 - tmp101;
c_im(inout[3 * iostride]) = tmp101 + tmp102;
}
{
fftw_real tmp53;
fftw_real tmp106;
fftw_real tmp76;
fftw_real tmp107;
fftw_real tmp80;
fftw_real tmp103;
fftw_real tmp77;
fftw_real tmp108;
ASSERT_ALIGNED_DOUBLE;
tmp53 = tmp49 + tmp52;
tmp106 = tmp104 + tmp105;
{
fftw_real tmp64;
fftw_real tmp75;
fftw_real tmp78;
fftw_real tmp79;
ASSERT_ALIGNED_DOUBLE;
tmp64 = (K766044443 * tmp58) + (K642787609 * tmp63);
tmp75 = (K173648177 * tmp69) + (K984807753 * tmp74);
tmp76 = tmp64 + tmp75;
tmp107 = K866025403 * (tmp75 - tmp64);
tmp78 = (K766044443 * tmp63) - (K642787609 * tmp58);
tmp79 = (K173648177 * tmp74) - (K984807753 * tmp69);
tmp80 = K866025403 * (tmp78 - tmp79);
tmp103 = tmp78 + tmp79;
}
c_re(inout[iostride]) = tmp53 + tmp76;
tmp77 = tmp53 - (K500000000 * tmp76);
c_re(inout[7 * iostride]) = tmp77 - tmp80;
c_re(inout[4 * iostride]) = tmp77 + tmp80;
c_im(inout[iostride]) = tmp103 + tmp106;
tmp108 = tmp106 - (K500000000 * tmp103);
c_im(inout[4 * iostride]) = tmp107 + tmp108;
c_im(inout[7 * iostride]) = tmp108 - tmp107;
}
{
fftw_real tmp81;
fftw_real tmp110;
fftw_real tmp88;
fftw_real tmp111;
fftw_real tmp92;
fftw_real tmp109;
fftw_real tmp89;
fftw_real tmp112;
ASSERT_ALIGNED_DOUBLE;
tmp81 = tmp49 - tmp52;
tmp110 = tmp105 - tmp104;
{
fftw_real tmp84;
fftw_real tmp87;
fftw_real tmp90;
fftw_real tmp91;
ASSERT_ALIGNED_DOUBLE;
tmp84 = (K173648177 * tmp82) + (K984807753 * tmp83);
tmp87 = (K342020143 * tmp85) - (K939692620 * tmp86);
tmp88 = tmp84 + tmp87;
tmp111 = K866025403 * (tmp87 - tmp84);
tmp90 = (K173648177 * tmp83) - (K984807753 * tmp82);
tmp91 = (K342020143 * tmp86) + (K939692620 * tmp85);
tmp92 = K866025403 * (tmp90 + tmp91);
tmp109 = tmp90 - tmp91;
}
c_re(inout[2 * iostride]) = tmp81 + tmp88;
tmp89 = tmp81 - (K500000000 * tmp88);
c_re(inout[8 * iostride]) = tmp89 - tmp92;
c_re(inout[5 * iostride]) = tmp89 + tmp92;
c_im(inout[2 * iostride]) = tmp109 + tmp110;
tmp112 = tmp110 - (K500000000 * tmp109);
c_im(inout[5 * iostride]) = tmp111 + tmp112;
c_im(inout[8 * iostride]) = tmp112 - tmp111;
}
}
}
void fftw_hc2hc_backward_3(fftw_real *A, const fftw_complex *W,
int iostride, int m, int dist)
{
int i;
fftw_real *X;
fftw_real *Y;
X = A;
Y = A + (3 * iostride);
{
fftw_real tmp30;
fftw_real tmp26;
fftw_real tmp27;
fftw_real tmp28;
fftw_real tmp29;
ASSERT_ALIGNED_DOUBLE;
tmp29 = Y[-iostride];
tmp30 = K1_732050807 * tmp29;
tmp26 = X[0];
tmp27 = X[iostride];
tmp28 = tmp26 - tmp27;
X[0] = tmp26 + (K2_000000000 * tmp27);
X[iostride] = tmp28 - tmp30;
X[2 * iostride] = tmp28 + tmp30;
}
X = X + dist;
Y = Y - dist;
for (i = 2; i < m; i = i + 2, X = X + dist, Y = Y - dist, W = W + 2) {
fftw_real tmp6;
fftw_real tmp9;
fftw_real tmp15;
fftw_real tmp19;
fftw_real tmp10;
fftw_real tmp13;
fftw_real tmp16;
fftw_real tmp20;
ASSERT_ALIGNED_DOUBLE;
{
fftw_real tmp7;
fftw_real tmp8;
fftw_real tmp11;
fftw_real tmp12;
ASSERT_ALIGNED_DOUBLE;
tmp6 = X[0];
tmp7 = X[iostride];
tmp8 = Y[-2 * iostride];
tmp9 = tmp7 + tmp8;
tmp15 = K866025403 * (tmp7 - tmp8);
tmp19 = tmp6 - (K500000000 * tmp9);
tmp10 = Y[0];
tmp11 = Y[-iostride];
tmp12 = X[2 * iostride];
tmp13 = tmp11 - tmp12;
tmp16 = tmp10 - (K500000000 * tmp13);
tmp20 = K866025403 * (tmp11 + tmp12);
}
X[0] = tmp6 + tmp9;
{
fftw_real tmp23;
fftw_real tmp25;
fftw_real tmp22;
fftw_real tmp24;
ASSERT_ALIGNED_DOUBLE;
tmp23 = tmp16 - tmp15;
tmp25 = tmp19 + tmp20;
tmp22 = c_re(W[1]);
tmp24 = c_im(W[1]);
Y[0] = (tmp22 * tmp23) - (tmp24 * tmp25);
X[2 * iostride] = (tmp24 * tmp23) + (tmp22 * tmp25);
}
Y[-2 * iostride] = tmp10 + tmp13;
{
fftw_real tmp17;
fftw_real tmp21;
fftw_real tmp14;
fftw_real tmp18;
ASSERT_ALIGNED_DOUBLE;
tmp17 = tmp15 + tmp16;
tmp21 = tmp19 - tmp20;
tmp14 = c_re(W[0]);
tmp18 = c_im(W[0]);
Y[-iostride] = (tmp14 * tmp17) - (tmp18 * tmp21);
X[iostride] = (tmp18 * tmp17) + (tmp14 * tmp21);
}
}
if (i == m) {
fftw_real tmp5;
fftw_real tmp1;
fftw_real tmp2;
fftw_real tmp3;
fftw_real tmp4;
ASSERT_ALIGNED_DOUBLE;
tmp4 = Y[0];
tmp5 = K1_732050807 * tmp4;
tmp1 = X[iostride];
tmp2 = X[0];
tmp3 = tmp2 - tmp1;
X[0] = tmp1 + (K2_000000000 * tmp2);
X[2 * iostride] = -(tmp3 + tmp5);
X[iostride] = tmp3 - tmp5;
}
}
void fftw_hc2hc_backward_6(fftw_real *A, const fftw_complex *W, int iostride, int m, int dist)
{
int i;
fftw_real *X;
fftw_real *Y;
X = A;
Y = A + (6 * iostride);
{
fftw_real tmp71;
fftw_real tmp75;
fftw_real tmp80;
fftw_real tmp82;
fftw_real tmp74;
fftw_real tmp76;
fftw_real tmp69;
fftw_real tmp70;
fftw_real tmp77;
fftw_real tmp81;
ASSERT_ALIGNED_DOUBLE();
tmp69 = X[0];
tmp70 = X[3 * iostride];
tmp71 = tmp69 - tmp70;
tmp75 = tmp69 + tmp70;
{
fftw_real tmp78;
fftw_real tmp79;
fftw_real tmp72;
fftw_real tmp73;
ASSERT_ALIGNED_DOUBLE();
tmp78 = Y[-2 * iostride];
tmp79 = Y[-iostride];
tmp80 = K1_732050807 * (tmp78 + tmp79);
tmp82 = K1_732050807 * (tmp78 - tmp79);
tmp72 = X[2 * iostride];
tmp73 = X[iostride];
tmp74 = tmp72 - tmp73;
tmp76 = tmp72 + tmp73;
}
X[3 * iostride] = tmp71 + (K2_000000000 * tmp74);
tmp77 = tmp71 - tmp74;
X[iostride] = tmp77 - tmp80;
X[5 * iostride] = tmp77 + tmp80;
X[0] = tmp75 + (K2_000000000 * tmp76);
tmp81 = tmp75 - tmp76;
X[2 * iostride] = tmp81 + tmp82;
X[4 * iostride] = tmp81 - tmp82;
}
X = X + dist;
Y = Y - dist;
for (i = 2; i < m; i = i + 2, X = X + dist, Y = Y - dist, W = W + 5) {
fftw_real tmp15;
fftw_real tmp46;
fftw_real tmp25;
fftw_real tmp52;
fftw_real tmp22;
fftw_real tmp35;
fftw_real tmp49;
fftw_real tmp62;
fftw_real tmp32;
fftw_real tmp39;
fftw_real tmp55;
fftw_real tmp59;
ASSERT_ALIGNED_DOUBLE();
{
fftw_real tmp13;
fftw_real tmp14;
fftw_real tmp23;
fftw_real tmp24;
ASSERT_ALIGNED_DOUBLE();
tmp13 = X[0];
tmp14 = Y[-3 * iostride];
tmp15 = tmp13 + tmp14;
tmp46 = tmp13 - tmp14;
tmp23 = Y[0];
tmp24 = X[3 * iostride];
tmp25 = tmp23 - tmp24;
tmp52 = tmp23 + tmp24;
}
{
fftw_real tmp18;
fftw_real tmp47;
fftw_real tmp21;
fftw_real tmp48;
ASSERT_ALIGNED_DOUBLE();
{
fftw_real tmp16;
fftw_real tmp17;
fftw_real tmp19;
fftw_real tmp20;
ASSERT_ALIGNED_DOUBLE();
tmp16 = X[2 * iostride];
tmp17 = Y[-5 * iostride];
tmp18 = tmp16 + tmp17;
tmp47 = tmp16 - tmp17;
tmp19 = Y[-4 * iostride];
tmp20 = X[iostride];
tmp21 = tmp19 + tmp20;
tmp48 = tmp19 - tmp20;
}
tmp22 = tmp18 + tmp21;
tmp35 = K866025403 * (tmp18 - tmp21);
tmp49 = tmp47 + tmp48;
tmp62 = K866025403 * (tmp47 - tmp48);
}
{
fftw_real tmp28;
fftw_real tmp54;
fftw_real tmp31;
fftw_real tmp53;
ASSERT_ALIGNED_DOUBLE();
{
fftw_real tmp26;
fftw_real tmp27;
fftw_real tmp29;
fftw_real tmp30;
ASSERT_ALIGNED_DOUBLE();
tmp26 = Y[-2 * iostride];
tmp27 = X[5 * iostride];
tmp28 = tmp26 - tmp27;
tmp54 = tmp26 + tmp27;
tmp29 = Y[-iostride];
tmp30 = X[4 * iostride];
tmp31 = tmp29 - tmp30;
tmp53 = tmp29 + tmp30;
}
tmp32 = tmp28 + tmp31;
tmp39 = K866025403 * (tmp31 - tmp28);
tmp55 = tmp53 - tmp54;
tmp59 = K866025403 * (tmp54 + tmp53);
}
X[0] = tmp15 + tmp22;
{
fftw_real tmp36;
fftw_real tmp42;
fftw_real tmp40;
fftw_real tmp44;
fftw_real tmp34;
fftw_real tmp38;
ASSERT_ALIGNED_DOUBLE();
tmp34 = tmp25 - (K500000000 * tmp32);
tmp36 = tmp34 - tmp35;
tmp42 = tmp35 + tmp34;
tmp38 = tmp15 - (K500000000 * tmp22);
tmp40 = tmp38 - tmp39;
tmp44 = tmp38 + tmp39;
{
fftw_real tmp33;
fftw_real tmp37;
fftw_real tmp41;
fftw_real tmp43;
ASSERT_ALIGNED_DOUBLE();
tmp33 = c_re(W[1]);
tmp37 = c_im(W[1]);
Y[-3 * iostride] = (tmp33 * tmp36) - (tmp37 * tmp40);
X[2 * iostride] = (tmp37 * tmp36) + (tmp33 * tmp40);
tmp41 = c_re(W[3]);
tmp43 = c_im(W[3]);
Y[-iostride] = (tmp41 * tmp42) - (tmp43 * tmp44);
X[4 * iostride] = (tmp43 * tmp42) + (tmp41 * tmp44);
}
}
Y[-5 * iostride] = tmp25 + tmp32;
{
fftw_real tmp50;
fftw_real tmp56;
fftw_real tmp45;
fftw_real tmp51;
ASSERT_ALIGNED_DOUBLE();
tmp50 = tmp46 + tmp49;
tmp56 = tmp52 - tmp55;
tmp45 = c_re(W[2]);
tmp51 = c_im(W[2]);
X[3 * iostride] = (tmp45 * tmp50) + (tmp51 * tmp56);
Y[-2 * iostride] = (tmp45 * tmp56) - (tmp51 * tmp50);
}
{
fftw_real tmp60;
fftw_real tmp66;
fftw_real tmp64;
fftw_real tmp68;
fftw_real tmp58;
fftw_real tmp63;
ASSERT_ALIGNED_DOUBLE();
tmp58 = tmp46 - (K500000000 * tmp49);
tmp60 = tmp58 - tmp59;
tmp66 = tmp58 + tmp59;
tmp63 = tmp52 + (K500000000 * tmp55);
tmp64 = tmp62 + tmp63;
tmp68 = tmp63 - tmp62;
{
fftw_real tmp57;
fftw_real tmp61;
fftw_real tmp65;
fftw_real tmp67;
ASSERT_ALIGNED_DOUBLE();
tmp57 = c_re(W[0]);
tmp61 = c_im(W[0]);
X[iostride] = (tmp57 * tmp60) + (tmp61 * tmp64);
Y[-4 * iostride] = (tmp57 * tmp64) - (tmp61 * tmp60);
tmp65 = c_re(W[4]);
tmp67 = c_im(W[4]);
X[5 * iostride] = (tmp65 * tmp66) + (tmp67 * tmp68);
Y[0] = (tmp65 * tmp68) - (tmp67 * tmp66);
}
}
}
if (i == m) {
fftw_real tmp1;
fftw_real tmp6;
fftw_real tmp4;
fftw_real tmp5;
fftw_real tmp9;
fftw_real tmp11;
fftw_real tmp12;
fftw_real tmp10;
ASSERT_ALIGNED_DOUBLE();
tmp1 = X[iostride];
tmp6 = Y[-iostride];
{
fftw_real tmp2;
fftw_real tmp3;
fftw_real tmp7;
fftw_real tmp8;
ASSERT_ALIGNED_DOUBLE();
tmp2 = X[2 * iostride];
tmp3 = X[0];
tmp4 = tmp2 + tmp3;
tmp5 = K1_732050807 * (tmp2 - tmp3);
tmp7 = Y[-2 * iostride];
tmp8 = Y[0];
tmp9 = tmp7 + tmp8;
tmp11 = K1_732050807 * (tmp7 - tmp8);
}
X[0] = K2_000000000 * (tmp1 + tmp4);
tmp12 = (K2_000000000 * tmp1) - tmp4;
X[2 * iostride] = tmp11 - tmp12;
X[4 * iostride] = tmp12 + tmp11;
X[3 * iostride] = K2_000000000 * (tmp6 - tmp9);
tmp10 = (K2_000000000 * tmp6) + tmp9;
X[iostride] = -(tmp5 + tmp10);
X[5 * iostride] = tmp5 - tmp10;
}
}
void fftw_twiddle_8(fftw_complex *A, const fftw_complex *W, int iostride, int m, int dist)
{
int i;
fftw_complex *inout;
inout = A;
for (i = m; i > 0; i = i - 1, inout = inout + dist, W = W + 7) {
fftw_real tmp7;
fftw_real tmp43;
fftw_real tmp71;
fftw_real tmp76;
fftw_real tmp41;
fftw_real tmp53;
fftw_real tmp56;
fftw_real tmp65;
fftw_real tmp18;
fftw_real tmp77;
fftw_real tmp46;
fftw_real tmp68;
fftw_real tmp30;
fftw_real tmp48;
fftw_real tmp51;
fftw_real tmp64;
ASSERT_ALIGNED_DOUBLE;
{
fftw_real tmp1;
fftw_real tmp70;
fftw_real tmp6;
fftw_real tmp69;
ASSERT_ALIGNED_DOUBLE;
tmp1 = c_re(inout[0]);
tmp70 = c_im(inout[0]);
{
fftw_real tmp3;
fftw_real tmp5;
fftw_real tmp2;
fftw_real tmp4;
ASSERT_ALIGNED_DOUBLE;
tmp3 = c_re(inout[4 * iostride]);
tmp5 = c_im(inout[4 * iostride]);
tmp2 = c_re(W[3]);
tmp4 = c_im(W[3]);
tmp6 = (tmp2 * tmp3) - (tmp4 * tmp5);
tmp69 = (tmp4 * tmp3) + (tmp2 * tmp5);
}
tmp7 = tmp1 + tmp6;
tmp43 = tmp1 - tmp6;
tmp71 = tmp69 + tmp70;
tmp76 = tmp70 - tmp69;
}
{
fftw_real tmp35;
fftw_real tmp54;
fftw_real tmp40;
fftw_real tmp55;
ASSERT_ALIGNED_DOUBLE;
{
fftw_real tmp32;
fftw_real tmp34;
fftw_real tmp31;
fftw_real tmp33;
ASSERT_ALIGNED_DOUBLE;
tmp32 = c_re(inout[7 * iostride]);
tmp34 = c_im(inout[7 * iostride]);
tmp31 = c_re(W[6]);
tmp33 = c_im(W[6]);
tmp35 = (tmp31 * tmp32) - (tmp33 * tmp34);
tmp54 = (tmp33 * tmp32) + (tmp31 * tmp34);
}
{
fftw_real tmp37;
fftw_real tmp39;
fftw_real tmp36;
fftw_real tmp38;
ASSERT_ALIGNED_DOUBLE;
tmp37 = c_re(inout[3 * iostride]);
tmp39 = c_im(inout[3 * iostride]);
tmp36 = c_re(W[2]);
tmp38 = c_im(W[2]);
tmp40 = (tmp36 * tmp37) - (tmp38 * tmp39);
tmp55 = (tmp38 * tmp37) + (tmp36 * tmp39);
}
tmp41 = tmp35 + tmp40;
tmp53 = tmp35 - tmp40;
tmp56 = tmp54 - tmp55;
tmp65 = tmp54 + tmp55;
}
{
fftw_real tmp12;
fftw_real tmp44;
fftw_real tmp17;
fftw_real tmp45;
ASSERT_ALIGNED_DOUBLE;
{
fftw_real tmp9;
fftw_real tmp11;
fftw_real tmp8;
fftw_real tmp10;
ASSERT_ALIGNED_DOUBLE;
tmp9 = c_re(inout[2 * iostride]);
tmp11 = c_im(inout[2 * iostride]);
tmp8 = c_re(W[1]);
tmp10 = c_im(W[1]);
tmp12 = (tmp8 * tmp9) - (tmp10 * tmp11);
tmp44 = (tmp10 * tmp9) + (tmp8 * tmp11);
}
{
fftw_real tmp14;
fftw_real tmp16;
fftw_real tmp13;
fftw_real tmp15;
ASSERT_ALIGNED_DOUBLE;
tmp14 = c_re(inout[6 * iostride]);
tmp16 = c_im(inout[6 * iostride]);
tmp13 = c_re(W[5]);
tmp15 = c_im(W[5]);
tmp17 = (tmp13 * tmp14) - (tmp15 * tmp16);
tmp45 = (tmp15 * tmp14) + (tmp13 * tmp16);
}
tmp18 = tmp12 + tmp17;
tmp77 = tmp12 - tmp17;
tmp46 = tmp44 - tmp45;
tmp68 = tmp44 + tmp45;
}
{
fftw_real tmp24;
fftw_real tmp49;
fftw_real tmp29;
fftw_real tmp50;
ASSERT_ALIGNED_DOUBLE;
{
fftw_real tmp21;
fftw_real tmp23;
fftw_real tmp20;
fftw_real tmp22;
ASSERT_ALIGNED_DOUBLE;
tmp21 = c_re(inout[iostride]);
tmp23 = c_im(inout[iostride]);
tmp20 = c_re(W[0]);
tmp22 = c_im(W[0]);
tmp24 = (tmp20 * tmp21) - (tmp22 * tmp23);
tmp49 = (tmp22 * tmp21) + (tmp20 * tmp23);
}
{
fftw_real tmp26;
fftw_real tmp28;
fftw_real tmp25;
fftw_real tmp27;
ASSERT_ALIGNED_DOUBLE;
tmp26 = c_re(inout[5 * iostride]);
tmp28 = c_im(inout[5 * iostride]);
tmp25 = c_re(W[4]);
tmp27 = c_im(W[4]);
tmp29 = (tmp25 * tmp26) - (tmp27 * tmp28);
tmp50 = (tmp27 * tmp26) + (tmp25 * tmp28);
}
tmp30 = tmp24 + tmp29;
tmp48 = tmp24 - tmp29;
tmp51 = tmp49 - tmp50;
tmp64 = tmp49 + tmp50;
}
{
fftw_real tmp19;
fftw_real tmp42;
fftw_real tmp63;
fftw_real tmp66;
ASSERT_ALIGNED_DOUBLE;
tmp19 = tmp7 + tmp18;
tmp42 = tmp30 + tmp41;
c_re(inout[4 * iostride]) = tmp19 - tmp42;
c_re(inout[0]) = tmp19 + tmp42;
{
fftw_real tmp73;
fftw_real tmp74;
fftw_real tmp67;
fftw_real tmp72;
ASSERT_ALIGNED_DOUBLE;
tmp73 = tmp41 - tmp30;
tmp74 = tmp71 - tmp68;
c_im(inout[2 * iostride]) = tmp73 + tmp74;
c_im(inout[6 * iostride]) = tmp74 - tmp73;
tmp67 = tmp64 + tmp65;
tmp72 = tmp68 + tmp71;
c_im(inout[0]) = tmp67 + tmp72;
c_im(inout[4 * iostride]) = tmp72 - tmp67;
}
tmp63 = tmp7 - tmp18;
tmp66 = tmp64 - tmp65;
c_re(inout[6 * iostride]) = tmp63 - tmp66;
c_re(inout[2 * iostride]) = tmp63 + tmp66;
{
fftw_real tmp59;
fftw_real tmp78;
fftw_real tmp62;
fftw_real tmp75;
fftw_real tmp60;
fftw_real tmp61;
ASSERT_ALIGNED_DOUBLE;
tmp59 = tmp43 - tmp46;
tmp78 = tmp76 - tmp77;
tmp60 = tmp51 - tmp48;
tmp61 = tmp53 + tmp56;
tmp62 = K707106781 * (tmp60 - tmp61);
tmp75 = K707106781 * (tmp60 + tmp61);
c_re(inout[7 * iostride]) = tmp59 - tmp62;
c_re(inout[3 * iostride]) = tmp59 + tmp62;
c_im(inout[iostride]) = tmp75 + tmp78;
c_im(inout[5 * iostride]) = tmp78 - tmp75;
}
{
fftw_real tmp47;
fftw_real tmp80;
fftw_real tmp58;
fftw_real tmp79;
fftw_real tmp52;
fftw_real tmp57;
ASSERT_ALIGNED_DOUBLE;
tmp47 = tmp43 + tmp46;
tmp80 = tmp77 + tmp76;
tmp52 = tmp48 + tmp51;
tmp57 = tmp53 - tmp56;
tmp58 = K707106781 * (tmp52 + tmp57);
tmp79 = K707106781 * (tmp57 - tmp52);
c_re(inout[5 * iostride]) = tmp47 - tmp58;
c_re(inout[iostride]) = tmp47 + tmp58;
c_im(inout[3 * iostride]) = tmp79 + tmp80;
c_im(inout[7 * iostride]) = tmp80 - tmp79;
}
}
}
}
void fftwi_no_twiddle_32(const fftw_complex *input, fftw_complex *output, int istride, int ostride)
{
fftw_real tmp7;
fftw_real tmp339;
fftw_real tmp70;
fftw_real tmp313;
fftw_real tmp97;
fftw_real tmp215;
fftw_real tmp179;
fftw_real tmp241;
fftw_real tmp14;
fftw_real tmp314;
fftw_real tmp77;
fftw_real tmp340;
fftw_real tmp182;
fftw_real tmp216;
fftw_real tmp104;
fftw_real tmp242;
fftw_real tmp153;
fftw_real tmp236;
fftw_real tmp53;
fftw_real tmp60;
fftw_real tmp287;
fftw_real tmp336;
fftw_real tmp360;
fftw_real tmp290;
fftw_real tmp293;
fftw_real tmp294;
fftw_real tmp170;
fftw_real tmp233;
fftw_real tmp333;
fftw_real tmp359;
fftw_real tmp164;
fftw_real tmp234;
fftw_real tmp173;
fftw_real tmp237;
fftw_real tmp22;
fftw_real tmp318;
fftw_real tmp343;
fftw_real tmp85;
fftw_real tmp112;
fftw_real tmp185;
fftw_real tmp220;
fftw_real tmp245;
fftw_real tmp29;
fftw_real tmp321;
fftw_real tmp342;
fftw_real tmp92;
fftw_real tmp119;
fftw_real tmp184;
fftw_real tmp223;
fftw_real tmp244;
fftw_real tmp126;
fftw_real tmp229;
fftw_real tmp38;
fftw_real tmp45;
fftw_real tmp278;
fftw_real tmp329;
fftw_real tmp357;
fftw_real tmp281;
fftw_real tmp284;
fftw_real tmp285;
fftw_real tmp143;
fftw_real tmp226;
fftw_real tmp326;
fftw_real tmp356;
fftw_real tmp137;
fftw_real tmp227;
fftw_real tmp146;
fftw_real tmp230;
ASSERT_ALIGNED_DOUBLE;
{
fftw_real tmp3;
fftw_real tmp177;
fftw_real tmp66;
fftw_real tmp96;
fftw_real tmp6;
fftw_real tmp95;
fftw_real tmp69;
fftw_real tmp178;
ASSERT_ALIGNED_DOUBLE;
{
fftw_real tmp1;
fftw_real tmp2;
fftw_real tmp64;
fftw_real tmp65;
ASSERT_ALIGNED_DOUBLE;
tmp1 = c_re(input[0]);
tmp2 = c_re(input[16 * istride]);
tmp3 = tmp1 + tmp2;
tmp177 = tmp1 - tmp2;
tmp64 = c_im(input[0]);
tmp65 = c_im(input[16 * istride]);
tmp66 = tmp64 + tmp65;
tmp96 = tmp64 - tmp65;
}
{
fftw_real tmp4;
fftw_real tmp5;
fftw_real tmp67;
fftw_real tmp68;
ASSERT_ALIGNED_DOUBLE;
tmp4 = c_re(input[8 * istride]);
tmp5 = c_re(input[24 * istride]);
tmp6 = tmp4 + tmp5;
tmp95 = tmp4 - tmp5;
tmp67 = c_im(input[8 * istride]);
tmp68 = c_im(input[24 * istride]);
tmp69 = tmp67 + tmp68;
tmp178 = tmp67 - tmp68;
}
tmp7 = tmp3 + tmp6;
tmp339 = tmp3 - tmp6;
tmp70 = tmp66 + tmp69;
tmp313 = tmp66 - tmp69;
tmp97 = tmp95 + tmp96;
tmp215 = tmp96 - tmp95;
tmp179 = tmp177 - tmp178;
tmp241 = tmp177 + tmp178;
}
{
fftw_real tmp10;
fftw_real tmp98;
fftw_real tmp73;
fftw_real tmp99;
fftw_real tmp13;
fftw_real tmp102;
fftw_real tmp76;
fftw_real tmp101;
ASSERT_ALIGNED_DOUBLE;
{
fftw_real tmp8;
fftw_real tmp9;
fftw_real tmp71;
fftw_real tmp72;
ASSERT_ALIGNED_DOUBLE;
tmp8 = c_re(input[4 * istride]);
tmp9 = c_re(input[20 * istride]);
tmp10 = tmp8 + tmp9;
tmp98 = tmp8 - tmp9;
tmp71 = c_im(input[4 * istride]);
tmp72 = c_im(input[20 * istride]);
tmp73 = tmp71 + tmp72;
tmp99 = tmp71 - tmp72;
}
{
fftw_real tmp11;
fftw_real tmp12;
fftw_real tmp74;
fftw_real tmp75;
ASSERT_ALIGNED_DOUBLE;
tmp11 = c_re(input[28 * istride]);
tmp12 = c_re(input[12 * istride]);
tmp13 = tmp11 + tmp12;
tmp102 = tmp11 - tmp12;
tmp74 = c_im(input[28 * istride]);
tmp75 = c_im(input[12 * istride]);
tmp76 = tmp74 + tmp75;
tmp101 = tmp74 - tmp75;
}
tmp14 = tmp10 + tmp13;
tmp314 = tmp10 - tmp13;
tmp77 = tmp73 + tmp76;
tmp340 = tmp76 - tmp73;
{
fftw_real tmp180;
fftw_real tmp181;
fftw_real tmp100;
fftw_real tmp103;
ASSERT_ALIGNED_DOUBLE;
tmp180 = tmp98 - tmp99;
tmp181 = tmp102 + tmp101;
tmp182 = K707106781 * (tmp180 + tmp181);
tmp216 = K707106781 * (tmp180 - tmp181);
tmp100 = tmp98 + tmp99;
tmp103 = tmp101 - tmp102;
tmp104 = K707106781 * (tmp100 + tmp103);
tmp242 = K707106781 * (tmp103 - tmp100);
}
}
{
fftw_real tmp49;
fftw_real tmp149;
fftw_real tmp169;
fftw_real tmp288;
fftw_real tmp52;
fftw_real tmp166;
fftw_real tmp152;
fftw_real tmp289;
fftw_real tmp56;
fftw_real tmp154;
fftw_real tmp157;
fftw_real tmp291;
fftw_real tmp59;
fftw_real tmp159;
fftw_real tmp162;
fftw_real tmp292;
ASSERT_ALIGNED_DOUBLE;
{
fftw_real tmp47;
fftw_real tmp48;
fftw_real tmp167;
fftw_real tmp168;
ASSERT_ALIGNED_DOUBLE;
tmp47 = c_re(input[31 * istride]);
tmp48 = c_re(input[15 * istride]);
tmp49 = tmp47 + tmp48;
tmp149 = tmp47 - tmp48;
tmp167 = c_im(input[31 * istride]);
tmp168 = c_im(input[15 * istride]);
tmp169 = tmp167 - tmp168;
tmp288 = tmp167 + tmp168;
}
{
fftw_real tmp50;
fftw_real tmp51;
fftw_real tmp150;
fftw_real tmp151;
ASSERT_ALIGNED_DOUBLE;
tmp50 = c_re(input[7 * istride]);
tmp51 = c_re(input[23 * istride]);
tmp52 = tmp50 + tmp51;
tmp166 = tmp50 - tmp51;
tmp150 = c_im(input[7 * istride]);
tmp151 = c_im(input[23 * istride]);
tmp152 = tmp150 - tmp151;
tmp289 = tmp150 + tmp151;
}
{
fftw_real tmp54;
fftw_real tmp55;
fftw_real tmp155;
fftw_real tmp156;
ASSERT_ALIGNED_DOUBLE;
tmp54 = c_re(input[3 * istride]);
tmp55 = c_re(input[19 * istride]);
tmp56 = tmp54 + tmp55;
tmp154 = tmp54 - tmp55;
tmp155 = c_im(input[3 * istride]);
tmp156 = c_im(input[19 * istride]);
tmp157 = tmp155 - tmp156;
tmp291 = tmp155 + tmp156;
}
{
fftw_real tmp57;
fftw_real tmp58;
fftw_real tmp160;
fftw_real tmp161;
ASSERT_ALIGNED_DOUBLE;
tmp57 = c_re(input[27 * istride]);
tmp58 = c_re(input[11 * istride]);
tmp59 = tmp57 + tmp58;
tmp159 = tmp57 - tmp58;
tmp160 = c_im(input[27 * istride]);
tmp161 = c_im(input[11 * istride]);
tmp162 = tmp160 - tmp161;
tmp292 = tmp160 + tmp161;
}
{
fftw_real tmp334;
fftw_real tmp335;
fftw_real tmp331;
fftw_real tmp332;
ASSERT_ALIGNED_DOUBLE;
tmp153 = tmp149 - tmp152;
tmp236 = tmp149 + tmp152;
tmp53 = tmp49 + tmp52;
tmp60 = tmp56 + tmp59;
tmp287 = tmp53 - tmp60;
tmp334 = tmp49 - tmp52;
tmp335 = tmp292 - tmp291;
tmp336 = tmp334 - tmp335;
tmp360 = tmp334 + tmp335;
tmp290 = tmp288 + tmp289;
tmp293 = tmp291 + tmp292;
tmp294 = tmp290 - tmp293;
tmp170 = tmp166 + tmp169;
tmp233 = tmp169 - tmp166;
tmp331 = tmp288 - tmp289;
tmp332 = tmp56 - tmp59;
tmp333 = tmp331 - tmp332;
tmp359 = tmp332 + tmp331;
{
fftw_real tmp158;
fftw_real tmp163;
fftw_real tmp171;
fftw_real tmp172;
ASSERT_ALIGNED_DOUBLE;
tmp158 = tmp154 - tmp157;
tmp163 = tmp159 + tmp162;
tmp164 = K707106781 * (tmp158 + tmp163);
tmp234 = K707106781 * (tmp158 - tmp163);
tmp171 = tmp154 + tmp157;
tmp172 = tmp162 - tmp159;
tmp173 = K707106781 * (tmp171 + tmp172);
tmp237 = K707106781 * (tmp172 - tmp171);
}
}
}
{
fftw_real tmp18;
fftw_real tmp106;
fftw_real tmp81;
fftw_real tmp110;
fftw_real tmp21;
fftw_real tmp109;
fftw_real tmp84;
fftw_real tmp107;
fftw_real tmp316;
fftw_real tmp317;
ASSERT_ALIGNED_DOUBLE;
{
fftw_real tmp16;
fftw_real tmp17;
fftw_real tmp79;
fftw_real tmp80;
ASSERT_ALIGNED_DOUBLE;
tmp16 = c_re(input[2 * istride]);
tmp17 = c_re(input[18 * istride]);
tmp18 = tmp16 + tmp17;
tmp106 = tmp16 - tmp17;
tmp79 = c_im(input[2 * istride]);
tmp80 = c_im(input[18 * istride]);
tmp81 = tmp79 + tmp80;
tmp110 = tmp79 - tmp80;
}
{
fftw_real tmp19;
fftw_real tmp20;
fftw_real tmp82;
fftw_real tmp83;
ASSERT_ALIGNED_DOUBLE;
tmp19 = c_re(input[10 * istride]);
tmp20 = c_re(input[26 * istride]);
tmp21 = tmp19 + tmp20;
tmp109 = tmp19 - tmp20;
tmp82 = c_im(input[10 * istride]);
tmp83 = c_im(input[26 * istride]);
tmp84 = tmp82 + tmp83;
tmp107 = tmp82 - tmp83;
}
tmp22 = tmp18 + tmp21;
tmp316 = tmp18 - tmp21;
tmp317 = tmp81 - tmp84;
tmp318 = tmp316 - tmp317;
tmp343 = tmp316 + tmp317;
tmp85 = tmp81 + tmp84;
{
fftw_real tmp108;
fftw_real tmp111;
fftw_real tmp218;
fftw_real tmp219;
ASSERT_ALIGNED_DOUBLE;
tmp108 = tmp106 - tmp107;
tmp111 = tmp109 + tmp110;
tmp112 = (K923879532 * tmp108) - (K382683432 * tmp111);
tmp185 = (K923879532 * tmp111) + (K382683432 * tmp108);
tmp218 = tmp106 + tmp107;
tmp219 = tmp110 - tmp109;
tmp220 = (K382683432 * tmp218) - (K923879532 * tmp219);
tmp245 = (K382683432 * tmp219) + (K923879532 * tmp218);
}
}
{
fftw_real tmp25;
fftw_real tmp116;
fftw_real tmp88;
fftw_real tmp114;
fftw_real tmp28;
fftw_real tmp113;
fftw_real tmp91;
fftw_real tmp117;
fftw_real tmp319;
fftw_real tmp320;
ASSERT_ALIGNED_DOUBLE;
{
fftw_real tmp23;
fftw_real tmp24;
fftw_real tmp86;
fftw_real tmp87;
ASSERT_ALIGNED_DOUBLE;
tmp23 = c_re(input[30 * istride]);
tmp24 = c_re(input[14 * istride]);
tmp25 = tmp23 + tmp24;
tmp116 = tmp23 - tmp24;
tmp86 = c_im(input[30 * istride]);
tmp87 = c_im(input[14 * istride]);
tmp88 = tmp86 + tmp87;
tmp114 = tmp86 - tmp87;
}
{
fftw_real tmp26;
fftw_real tmp27;
fftw_real tmp89;
fftw_real tmp90;
ASSERT_ALIGNED_DOUBLE;
tmp26 = c_re(input[6 * istride]);
tmp27 = c_re(input[22 * istride]);
tmp28 = tmp26 + tmp27;
tmp113 = tmp26 - tmp27;
tmp89 = c_im(input[6 * istride]);
tmp90 = c_im(input[22 * istride]);
tmp91 = tmp89 + tmp90;
tmp117 = tmp89 - tmp90;
}
tmp29 = tmp25 + tmp28;
tmp319 = tmp25 - tmp28;
tmp320 = tmp88 - tmp91;
tmp321 = tmp319 + tmp320;
tmp342 = tmp320 - tmp319;
tmp92 = tmp88 + tmp91;
{
fftw_real tmp115;
fftw_real tmp118;
fftw_real tmp221;
fftw_real tmp222;
ASSERT_ALIGNED_DOUBLE;
tmp115 = tmp113 + tmp114;
tmp118 = tmp116 - tmp117;
tmp119 = (K382683432 * tmp115) + (K923879532 * tmp118);
tmp184 = (K923879532 * tmp115) - (K382683432 * tmp118);
tmp221 = tmp114 - tmp113;
tmp222 = tmp116 + tmp117;
tmp223 = (K923879532 * tmp221) + (K382683432 * tmp222);
tmp244 = (K382683432 * tmp221) - (K923879532 * tmp222);
}
}
{
fftw_real tmp34;
fftw_real tmp122;
fftw_real tmp142;
fftw_real tmp279;
fftw_real tmp37;
fftw_real tmp139;
fftw_real tmp125;
fftw_real tmp280;
fftw_real tmp41;
fftw_real tmp127;
fftw_real tmp130;
fftw_real tmp282;
fftw_real tmp44;
fftw_real tmp132;
fftw_real tmp135;
fftw_real tmp283;
ASSERT_ALIGNED_DOUBLE;
{
fftw_real tmp32;
fftw_real tmp33;
fftw_real tmp140;
fftw_real tmp141;
ASSERT_ALIGNED_DOUBLE;
tmp32 = c_re(input[istride]);
tmp33 = c_re(input[17 * istride]);
tmp34 = tmp32 + tmp33;
tmp122 = tmp32 - tmp33;
tmp140 = c_im(input[istride]);
tmp141 = c_im(input[17 * istride]);
tmp142 = tmp140 - tmp141;
tmp279 = tmp140 + tmp141;
}
{
fftw_real tmp35;
fftw_real tmp36;
fftw_real tmp123;
fftw_real tmp124;
ASSERT_ALIGNED_DOUBLE;
tmp35 = c_re(input[9 * istride]);
tmp36 = c_re(input[25 * istride]);
tmp37 = tmp35 + tmp36;
tmp139 = tmp35 - tmp36;
tmp123 = c_im(input[9 * istride]);
tmp124 = c_im(input[25 * istride]);
tmp125 = tmp123 - tmp124;
tmp280 = tmp123 + tmp124;
}
{
fftw_real tmp39;
fftw_real tmp40;
fftw_real tmp128;
fftw_real tmp129;
ASSERT_ALIGNED_DOUBLE;
tmp39 = c_re(input[5 * istride]);
tmp40 = c_re(input[21 * istride]);
tmp41 = tmp39 + tmp40;
tmp127 = tmp39 - tmp40;
tmp128 = c_im(input[5 * istride]);
tmp129 = c_im(input[21 * istride]);
tmp130 = tmp128 - tmp129;
tmp282 = tmp128 + tmp129;
}
{
fftw_real tmp42;
fftw_real tmp43;
fftw_real tmp133;
fftw_real tmp134;
ASSERT_ALIGNED_DOUBLE;
tmp42 = c_re(input[29 * istride]);
tmp43 = c_re(input[13 * istride]);
tmp44 = tmp42 + tmp43;
tmp132 = tmp42 - tmp43;
tmp133 = c_im(input[29 * istride]);
tmp134 = c_im(input[13 * istride]);
tmp135 = tmp133 - tmp134;
tmp283 = tmp133 + tmp134;
}
{
fftw_real tmp327;
fftw_real tmp328;
fftw_real tmp324;
fftw_real tmp325;
ASSERT_ALIGNED_DOUBLE;
tmp126 = tmp122 - tmp125;
tmp229 = tmp122 + tmp125;
tmp38 = tmp34 + tmp37;
tmp45 = tmp41 + tmp44;
tmp278 = tmp38 - tmp45;
tmp327 = tmp34 - tmp37;
tmp328 = tmp283 - tmp282;
tmp329 = tmp327 - tmp328;
tmp357 = tmp327 + tmp328;
tmp281 = tmp279 + tmp280;
tmp284 = tmp282 + tmp283;
tmp285 = tmp281 - tmp284;
tmp143 = tmp139 + tmp142;
tmp226 = tmp142 - tmp139;
tmp324 = tmp279 - tmp280;
tmp325 = tmp41 - tmp44;
tmp326 = tmp324 - tmp325;
tmp356 = tmp325 + tmp324;
{
fftw_real tmp131;
fftw_real tmp136;
fftw_real tmp144;
fftw_real tmp145;
ASSERT_ALIGNED_DOUBLE;
tmp131 = tmp127 - tmp130;
tmp136 = tmp132 + tmp135;
tmp137 = K707106781 * (tmp131 + tmp136);
tmp227 = K707106781 * (tmp131 - tmp136);
tmp144 = tmp127 + tmp130;
tmp145 = tmp135 - tmp132;
tmp146 = K707106781 * (tmp144 + tmp145);
tmp230 = K707106781 * (tmp145 - tmp144);
}
}
}
{
fftw_real tmp277;
fftw_real tmp301;
fftw_real tmp304;
fftw_real tmp306;
fftw_real tmp296;
fftw_real tmp300;
fftw_real tmp299;
fftw_real tmp305;
ASSERT_ALIGNED_DOUBLE;
{
fftw_real tmp275;
fftw_real tmp276;
fftw_real tmp302;
fftw_real tmp303;
ASSERT_ALIGNED_DOUBLE;
tmp275 = tmp70 - tmp77;
tmp276 = tmp22 - tmp29;
tmp277 = tmp275 - tmp276;
tmp301 = tmp276 + tmp275;
tmp302 = tmp278 + tmp285;
tmp303 = tmp294 - tmp287;
tmp304 = K707106781 * (tmp302 + tmp303);
tmp306 = K707106781 * (tmp303 - tmp302);
}
{
fftw_real tmp286;
fftw_real tmp295;
fftw_real tmp297;
fftw_real tmp298;
ASSERT_ALIGNED_DOUBLE;
tmp286 = tmp278 - tmp285;
tmp295 = tmp287 + tmp294;
tmp296 = K707106781 * (tmp286 - tmp295);
tmp300 = K707106781 * (tmp286 + tmp295);
tmp297 = tmp7 - tmp14;
tmp298 = tmp92 - tmp85;
tmp299 = tmp297 + tmp298;
tmp305 = tmp297 - tmp298;
}
c_im(output[28 * ostride]) = tmp277 - tmp296;
c_im(output[12 * ostride]) = tmp277 + tmp296;
c_re(output[20 * ostride]) = tmp299 - tmp300;
c_re(output[4 * ostride]) = tmp299 + tmp300;
c_im(output[20 * ostride]) = tmp301 - tmp304;
c_im(output[4 * ostride]) = tmp301 + tmp304;
c_re(output[28 * ostride]) = tmp305 - tmp306;
c_re(output[12 * ostride]) = tmp305 + tmp306;
}
{
fftw_real tmp31;
fftw_real tmp311;
fftw_real tmp310;
fftw_real tmp312;
fftw_real tmp62;
fftw_real tmp63;
fftw_real tmp94;
fftw_real tmp307;
ASSERT_ALIGNED_DOUBLE;
{
fftw_real tmp15;
fftw_real tmp30;
fftw_real tmp308;
fftw_real tmp309;
ASSERT_ALIGNED_DOUBLE;
tmp15 = tmp7 + tmp14;
tmp30 = tmp22 + tmp29;
tmp31 = tmp15 + tmp30;
tmp311 = tmp15 - tmp30;
tmp308 = tmp281 + tmp284;
tmp309 = tmp290 + tmp293;
tmp310 = tmp308 + tmp309;
tmp312 = tmp309 - tmp308;
}
{
fftw_real tmp46;
fftw_real tmp61;
fftw_real tmp78;
fftw_real tmp93;
ASSERT_ALIGNED_DOUBLE;
tmp46 = tmp38 + tmp45;
tmp61 = tmp53 + tmp60;
tmp62 = tmp46 + tmp61;
tmp63 = tmp46 - tmp61;
tmp78 = tmp70 + tmp77;
tmp93 = tmp85 + tmp92;
tmp94 = tmp78 - tmp93;
tmp307 = tmp78 + tmp93;
}
c_re(output[16 * ostride]) = tmp31 - tmp62;
c_re(output[0]) = tmp31 + tmp62;
c_im(output[8 * ostride]) = tmp63 + tmp94;
c_im(output[24 * ostride]) = tmp94 - tmp63;
c_im(output[16 * ostride]) = tmp307 - tmp310;
c_im(output[0]) = tmp307 + tmp310;
c_re(output[24 * ostride]) = tmp311 - tmp312;
c_re(output[8 * ostride]) = tmp311 + tmp312;
}
{
fftw_real tmp121;
fftw_real tmp189;
fftw_real tmp187;
fftw_real tmp193;
fftw_real tmp148;
fftw_real tmp190;
fftw_real tmp175;
fftw_real tmp191;
ASSERT_ALIGNED_DOUBLE;
{
fftw_real tmp105;
fftw_real tmp120;
fftw_real tmp183;
fftw_real tmp186;
ASSERT_ALIGNED_DOUBLE;
tmp105 = tmp97 - tmp104;
tmp120 = tmp112 - tmp119;
tmp121 = tmp105 - tmp120;
tmp189 = tmp105 + tmp120;
tmp183 = tmp179 - tmp182;
tmp186 = tmp184 - tmp185;
tmp187 = tmp183 + tmp186;
tmp193 = tmp183 - tmp186;
}
{
fftw_real tmp138;
fftw_real tmp147;
fftw_real tmp165;
fftw_real tmp174;
ASSERT_ALIGNED_DOUBLE;
tmp138 = tmp126 - tmp137;
tmp147 = tmp143 - tmp146;
tmp148 = (K555570233 * tmp138) - (K831469612 * tmp147);
tmp190 = (K831469612 * tmp138) + (K555570233 * tmp147);
tmp165 = tmp153 - tmp164;
tmp174 = tmp170 - tmp173;
tmp175 = (K555570233 * tmp165) + (K831469612 * tmp174);
tmp191 = (K555570233 * tmp174) - (K831469612 * tmp165);
}
{
fftw_real tmp176;
fftw_real tmp188;
fftw_real tmp192;
fftw_real tmp194;
ASSERT_ALIGNED_DOUBLE;
tmp176 = tmp148 - tmp175;
c_im(output[29 * ostride]) = tmp121 - tmp176;
c_im(output[13 * ostride]) = tmp121 + tmp176;
tmp188 = tmp148 + tmp175;
c_re(output[21 * ostride]) = tmp187 - tmp188;
c_re(output[5 * ostride]) = tmp187 + tmp188;
tmp192 = tmp190 + tmp191;
c_im(output[21 * ostride]) = tmp189 - tmp192;
c_im(output[5 * ostride]) = tmp189 + tmp192;
tmp194 = tmp191 - tmp190;
c_re(output[29 * ostride]) = tmp193 - tmp194;
c_re(output[13 * ostride]) = tmp193 + tmp194;
}
}
{
fftw_real tmp197;
fftw_real tmp209;
fftw_real tmp207;
fftw_real tmp213;
fftw_real tmp200;
fftw_real tmp210;
fftw_real tmp203;
fftw_real tmp211;
ASSERT_ALIGNED_DOUBLE;
{
fftw_real tmp195;
fftw_real tmp196;
fftw_real tmp205;
fftw_real tmp206;
ASSERT_ALIGNED_DOUBLE;
tmp195 = tmp97 + tmp104;
tmp196 = tmp185 + tmp184;
tmp197 = tmp195 - tmp196;
tmp209 = tmp195 + tmp196;
tmp205 = tmp179 + tmp182;
tmp206 = tmp112 + tmp119;
tmp207 = tmp205 + tmp206;
tmp213 = tmp205 - tmp206;
}
{
fftw_real tmp198;
fftw_real tmp199;
fftw_real tmp201;
fftw_real tmp202;
ASSERT_ALIGNED_DOUBLE;
tmp198 = tmp126 + tmp137;
tmp199 = tmp143 + tmp146;
tmp200 = (K980785280 * tmp198) - (K195090322 * tmp199);
tmp210 = (K195090322 * tmp198) + (K980785280 * tmp199);
tmp201 = tmp153 + tmp164;
tmp202 = tmp170 + tmp173;
tmp203 = (K980785280 * tmp201) + (K195090322 * tmp202);
tmp211 = (K980785280 * tmp202) - (K195090322 * tmp201);
}
{
fftw_real tmp204;
fftw_real tmp208;
fftw_real tmp212;
fftw_real tmp214;
ASSERT_ALIGNED_DOUBLE;
tmp204 = tmp200 - tmp203;
c_im(output[25 * ostride]) = tmp197 - tmp204;
c_im(output[9 * ostride]) = tmp197 + tmp204;
tmp208 = tmp200 + tmp203;
c_re(output[17 * ostride]) = tmp207 - tmp208;
c_re(output[ostride]) = tmp207 + tmp208;
tmp212 = tmp210 + tmp211;
c_im(output[17 * ostride]) = tmp209 - tmp212;
c_im(output[ostride]) = tmp209 + tmp212;
tmp214 = tmp211 - tmp210;
c_re(output[25 * ostride]) = tmp213 - tmp214;
c_re(output[9 * ostride]) = tmp213 + tmp214;
}
}
{
fftw_real tmp323;
fftw_real tmp347;
fftw_real tmp350;
fftw_real tmp352;
fftw_real tmp338;
fftw_real tmp346;
fftw_real tmp345;
fftw_real tmp351;
ASSERT_ALIGNED_DOUBLE;
{
fftw_real tmp315;
fftw_real tmp322;
fftw_real tmp348;
fftw_real tmp349;
ASSERT_ALIGNED_DOUBLE;
tmp315 = tmp313 - tmp314;
tmp322 = K707106781 * (tmp318 - tmp321);
tmp323 = tmp315 + tmp322;
tmp347 = tmp315 - tmp322;
tmp348 = (K382683432 * tmp329) - (K923879532 * tmp326);
tmp349 = (K923879532 * tmp333) + (K382683432 * tmp336);
tmp350 = tmp348 - tmp349;
tmp352 = tmp348 + tmp349;
}
{
fftw_real tmp330;
fftw_real tmp337;
fftw_real tmp341;
fftw_real tmp344;
ASSERT_ALIGNED_DOUBLE;
tmp330 = (K382683432 * tmp326) + (K923879532 * tmp329);
tmp337 = (K382683432 * tmp333) - (K923879532 * tmp336);
tmp338 = tmp330 + tmp337;
tmp346 = tmp337 - tmp330;
tmp341 = tmp339 - tmp340;
tmp344 = K707106781 * (tmp342 - tmp343);
tmp345 = tmp341 - tmp344;
tmp351 = tmp341 + tmp344;
}
c_im(output[22 * ostride]) = tmp323 - tmp338;
c_im(output[6 * ostride]) = tmp323 + tmp338;
c_re(output[30 * ostride]) = tmp345 - tmp346;
c_re(output[14 * ostride]) = tmp345 + tmp346;
c_im(output[30 * ostride]) = tmp347 - tmp350;
c_im(output[14 * ostride]) = tmp347 + tmp350;
c_re(output[22 * ostride]) = tmp351 - tmp352;
c_re(output[6 * ostride]) = tmp351 + tmp352;
}
{
fftw_real tmp355;
fftw_real tmp367;
fftw_real tmp370;
fftw_real tmp372;
fftw_real tmp362;
fftw_real tmp366;
fftw_real tmp365;
fftw_real tmp371;
ASSERT_ALIGNED_DOUBLE;
{
fftw_real tmp353;
fftw_real tmp354;
fftw_real tmp368;
fftw_real tmp369;
ASSERT_ALIGNED_DOUBLE;
tmp353 = tmp314 + tmp313;
tmp354 = K707106781 * (tmp343 + tmp342);
tmp355 = tmp353 + tmp354;
tmp367 = tmp353 - tmp354;
tmp368 = (K923879532 * tmp357) - (K382683432 * tmp356);
tmp369 = (K382683432 * tmp359) + (K923879532 * tmp360);
tmp370 = tmp368 - tmp369;
tmp372 = tmp368 + tmp369;
}
{
fftw_real tmp358;
fftw_real tmp361;
fftw_real tmp363;
fftw_real tmp364;
ASSERT_ALIGNED_DOUBLE;
tmp358 = (K923879532 * tmp356) + (K382683432 * tmp357);
tmp361 = (K923879532 * tmp359) - (K382683432 * tmp360);
tmp362 = tmp358 + tmp361;
tmp366 = tmp361 - tmp358;
tmp363 = tmp339 + tmp340;
tmp364 = K707106781 * (tmp318 + tmp321);
tmp365 = tmp363 - tmp364;
tmp371 = tmp363 + tmp364;
}
c_im(output[18 * ostride]) = tmp355 - tmp362;
c_im(output[2 * ostride]) = tmp355 + tmp362;
c_re(output[26 * ostride]) = tmp365 - tmp366;
c_re(output[10 * ostride]) = tmp365 + tmp366;
c_im(output[26 * ostride]) = tmp367 - tmp370;
c_im(output[10 * ostride]) = tmp367 + tmp370;
c_re(output[18 * ostride]) = tmp371 - tmp372;
c_re(output[2 * ostride]) = tmp371 + tmp372;
}
{
fftw_real tmp225;
fftw_real tmp249;
fftw_real tmp247;
fftw_real tmp253;
fftw_real tmp232;
fftw_real tmp250;
fftw_real tmp239;
fftw_real tmp251;
ASSERT_ALIGNED_DOUBLE;
{
fftw_real tmp217;
fftw_real tmp224;
fftw_real tmp243;
fftw_real tmp246;
ASSERT_ALIGNED_DOUBLE;
tmp217 = tmp215 - tmp216;
tmp224 = tmp220 - tmp223;
tmp225 = tmp217 + tmp224;
tmp249 = tmp217 - tmp224;
tmp243 = tmp241 - tmp242;
tmp246 = tmp244 - tmp245;
tmp247 = tmp243 - tmp246;
tmp253 = tmp243 + tmp246;
}
{
fftw_real tmp228;
fftw_real tmp231;
fftw_real tmp235;
fftw_real tmp238;
ASSERT_ALIGNED_DOUBLE;
tmp228 = tmp226 - tmp227;
tmp231 = tmp229 - tmp230;
tmp232 = (K195090322 * tmp228) + (K980785280 * tmp231);
tmp250 = (K195090322 * tmp231) - (K980785280 * tmp228);
tmp235 = tmp233 - tmp234;
tmp238 = tmp236 - tmp237;
tmp239 = (K195090322 * tmp235) - (K980785280 * tmp238);
tmp251 = (K980785280 * tmp235) + (K195090322 * tmp238);
}
{
fftw_real tmp240;
fftw_real tmp248;
fftw_real tmp252;
fftw_real tmp254;
ASSERT_ALIGNED_DOUBLE;
tmp240 = tmp232 + tmp239;
c_im(output[23 * ostride]) = tmp225 - tmp240;
c_im(output[7 * ostride]) = tmp225 + tmp240;
tmp248 = tmp239 - tmp232;
c_re(output[31 * ostride]) = tmp247 - tmp248;
c_re(output[15 * ostride]) = tmp247 + tmp248;
tmp252 = tmp250 - tmp251;
c_im(output[31 * ostride]) = tmp249 - tmp252;
c_im(output[15 * ostride]) = tmp249 + tmp252;
tmp254 = tmp250 + tmp251;
c_re(output[23 * ostride]) = tmp253 - tmp254;
c_re(output[7 * ostride]) = tmp253 + tmp254;
}
}
{
fftw_real tmp257;
fftw_real tmp269;
fftw_real tmp267;
fftw_real tmp273;
fftw_real tmp260;
fftw_real tmp270;
fftw_real tmp263;
fftw_real tmp271;
ASSERT_ALIGNED_DOUBLE;
{
fftw_real tmp255;
fftw_real tmp256;
fftw_real tmp265;
fftw_real tmp266;
ASSERT_ALIGNED_DOUBLE;
tmp255 = tmp215 + tmp216;
tmp256 = tmp245 + tmp244;
tmp257 = tmp255 + tmp256;
tmp269 = tmp255 - tmp256;
tmp265 = tmp241 + tmp242;
tmp266 = tmp220 + tmp223;
tmp267 = tmp265 - tmp266;
tmp273 = tmp265 + tmp266;
}
{
fftw_real tmp258;
fftw_real tmp259;
fftw_real tmp261;
fftw_real tmp262;
ASSERT_ALIGNED_DOUBLE;
tmp258 = tmp226 + tmp227;
tmp259 = tmp229 + tmp230;
tmp260 = (K831469612 * tmp258) + (K555570233 * tmp259);
tmp270 = (K831469612 * tmp259) - (K555570233 * tmp258);
tmp261 = tmp233 + tmp234;
tmp262 = tmp236 + tmp237;
tmp263 = (K831469612 * tmp261) - (K555570233 * tmp262);
tmp271 = (K555570233 * tmp261) + (K831469612 * tmp262);
}
{
fftw_real tmp264;
fftw_real tmp268;
fftw_real tmp272;
fftw_real tmp274;
ASSERT_ALIGNED_DOUBLE;
tmp264 = tmp260 + tmp263;
c_im(output[19 * ostride]) = tmp257 - tmp264;
c_im(output[3 * ostride]) = tmp257 + tmp264;
tmp268 = tmp263 - tmp260;
c_re(output[27 * ostride]) = tmp267 - tmp268;
c_re(output[11 * ostride]) = tmp267 + tmp268;
tmp272 = tmp270 - tmp271;
c_im(output[27 * ostride]) = tmp269 - tmp272;
c_im(output[11 * ostride]) = tmp269 + tmp272;
tmp274 = tmp270 + tmp271;
c_re(output[19 * ostride]) = tmp273 - tmp274;
c_re(output[3 * ostride]) = tmp273 + tmp274;
}
}
}
void fftwi_no_twiddle_7(const fftw_complex *input, fftw_complex *output,
int istride, int ostride)
{
fftw_real tmp1;
fftw_real tmp15;
fftw_real tmp4;
fftw_real tmp11;
fftw_real tmp21;
fftw_real tmp31;
fftw_real tmp7;
fftw_real tmp13;
fftw_real tmp24;
fftw_real tmp33;
fftw_real tmp10;
fftw_real tmp12;
fftw_real tmp18;
fftw_real tmp32;
ASSERT_ALIGNED_DOUBLE;
tmp1 = c_re(input[0]);
tmp15 = c_im(input[0]);
{
fftw_real tmp2;
fftw_real tmp3;
fftw_real tmp19;
fftw_real tmp20;
ASSERT_ALIGNED_DOUBLE;
tmp2 = c_re(input[istride]);
tmp3 = c_re(input[6 * istride]);
tmp4 = tmp2 + tmp3;
tmp11 = tmp2 - tmp3;
tmp19 = c_im(input[istride]);
tmp20 = c_im(input[6 * istride]);
tmp21 = tmp19 + tmp20;
tmp31 = tmp20 - tmp19;
}
{
fftw_real tmp5;
fftw_real tmp6;
fftw_real tmp22;
fftw_real tmp23;
ASSERT_ALIGNED_DOUBLE;
tmp5 = c_re(input[2 * istride]);
tmp6 = c_re(input[5 * istride]);
tmp7 = tmp5 + tmp6;
tmp13 = tmp5 - tmp6;
tmp22 = c_im(input[2 * istride]);
tmp23 = c_im(input[5 * istride]);
tmp24 = tmp22 + tmp23;
tmp33 = tmp23 - tmp22;
}
{
fftw_real tmp8;
fftw_real tmp9;
fftw_real tmp16;
fftw_real tmp17;
ASSERT_ALIGNED_DOUBLE;
tmp8 = c_re(input[3 * istride]);
tmp9 = c_re(input[4 * istride]);
tmp10 = tmp8 + tmp9;
tmp12 = tmp8 - tmp9;
tmp16 = c_im(input[3 * istride]);
tmp17 = c_im(input[4 * istride]);
tmp18 = tmp16 + tmp17;
tmp32 = tmp17 - tmp16;
}
{
fftw_real tmp36;
fftw_real tmp35;
fftw_real tmp26;
fftw_real tmp27;
ASSERT_ALIGNED_DOUBLE;
c_re(output[0]) = tmp1 + tmp4 + tmp7 + tmp10;
tmp36 =
(K974927912 * tmp33) + (K433883739 * tmp32) +
(K781831482 * tmp31);
tmp35 =
tmp1 + (K623489801 * tmp4) - (K900968867 * tmp10) -
(K222520933 * tmp7);
c_re(output[6 * ostride]) = tmp35 - tmp36;
c_re(output[ostride]) = tmp35 + tmp36;
{
fftw_real tmp38;
fftw_real tmp37;
fftw_real tmp34;
fftw_real tmp30;
ASSERT_ALIGNED_DOUBLE;
tmp38 =
(K974927912 * tmp32) + (K433883739 * tmp31) -
(K781831482 * tmp33);
tmp37 =
tmp1 + (K623489801 * tmp7) - (K222520933 * tmp10) -
(K900968867 * tmp4);
c_re(output[4 * ostride]) = tmp37 - tmp38;
c_re(output[3 * ostride]) = tmp37 + tmp38;
tmp34 =
(K974927912 * tmp31) - (K781831482 * tmp32) -
(K433883739 * tmp33);
tmp30 =
tmp1 + (K623489801 * tmp10) - (K900968867 * tmp7) -
(K222520933 * tmp4);
c_re(output[5 * ostride]) = tmp30 - tmp34;
c_re(output[2 * ostride]) = tmp30 + tmp34;
}
c_im(output[0]) = tmp15 + tmp24 + tmp18 + tmp21;
tmp26 =
(K433883739 * tmp11) + (K974927912 * tmp12) -
(K781831482 * tmp13);
tmp27 =
tmp15 + (K623489801 * tmp24) - (K900968867 * tmp21) -
(K222520933 * tmp18);
c_im(output[3 * ostride]) = tmp26 + tmp27;
c_im(output[4 * ostride]) = tmp27 - tmp26;
{
fftw_real tmp14;
fftw_real tmp25;
fftw_real tmp28;
fftw_real tmp29;
ASSERT_ALIGNED_DOUBLE;
tmp14 =
(K974927912 * tmp11) - (K781831482 * tmp12) -
(K433883739 * tmp13);
tmp25 =
tmp15 + (K623489801 * tmp18) - (K222520933 * tmp21) -
(K900968867 * tmp24);
c_im(output[2 * ostride]) = tmp14 + tmp25;
c_im(output[5 * ostride]) = tmp25 - tmp14;
tmp28 =
(K781831482 * tmp11) + (K974927912 * tmp13) +
(K433883739 * tmp12);
tmp29 =
tmp15 + (K623489801 * tmp21) - (K900968867 * tmp18) -
(K222520933 * tmp24);
c_im(output[ostride]) = tmp28 + tmp29;
c_im(output[6 * ostride]) = tmp29 - tmp28;
}
}
}
// this function walks through data loading every fourth element
// the purpose is to cache the data for a subsequent FFT
dist_fft_real prefetch_row(dist_fft_storage data,
int local_row,
int dimension)
{
// prefetching only speeds things up for very large dimensions
if (dimension < (1 << 13)) return 0;
int index = local_row * dimension;
int index1 = index;
int index2 = index+4;
int index3 = index+8;
int index4 = index+12;
double data_re1;
double data_im1;
double data_re2;
double data_im2;
double data_re3;
double data_im3;
double data_re4;
double data_im4;
int bigloopcount;
int bigloopindex;
dist_fft_real sum_re1 = 0, sum_im1 = 0, sum_re2 = 0, sum_im2 = 0;
dist_fft_real sum_re3 = 0, sum_im3 = 0, sum_re4 = 0, sum_im4 = 0;
bigloopcount = (dimension)/16;
for (bigloopindex=0; bigloopindex<bigloopcount; bigloopindex++) {
data_re1 = c_re(data, index1);
data_im1 = c_im(data, index1);
data_re2 = c_re(data, index2);
data_im2 = c_im(data, index2);
data_re3 = c_re(data, index3);
data_im3 = c_im(data, index3);
data_re4 = c_re(data, index4);
data_im4 = c_im(data, index4);
sum_re1 += data_re1;
sum_im1 += data_im1;
sum_re2 += data_re2;
sum_im2 += data_im2;
sum_re3 += data_re3;
sum_im3 += data_im3;
sum_re4 += data_re4;
sum_im4 += data_im4;
index1 += 16;
index2 += 16;
index3 += 16;
index4 += 16;
}
return sum_re1 * sum_im1 + sum_re2 * sum_im2 + sum_re3 * sum_im3 + sum_re4 * sum_im4;
}
void fftw_hc2hc_forward_3(fftw_real *A, const fftw_complex *W,
int iostride, int m, int dist)
{
int i;
fftw_real *X;
fftw_real *Y;
X = A;
Y = A + (3 * iostride);
{
fftw_real tmp24;
fftw_real tmp25;
fftw_real tmp26;
fftw_real tmp27;
ASSERT_ALIGNED_DOUBLE;
tmp24 = X[0];
tmp25 = X[iostride];
tmp26 = X[2 * iostride];
tmp27 = tmp25 + tmp26;
X[iostride] = tmp24 - (K500000000 * tmp27);
X[0] = tmp24 + tmp27;
Y[-iostride] = K866025403 * (tmp26 - tmp25);
}
X = X + dist;
Y = Y - dist;
for (i = 2; i < m; i = i + 2, X = X + dist, Y = Y - dist, W = W + 2) {
fftw_real tmp4;
fftw_real tmp21;
fftw_real tmp9;
fftw_real tmp17;
fftw_real tmp14;
fftw_real tmp18;
fftw_real tmp15;
fftw_real tmp20;
ASSERT_ALIGNED_DOUBLE;
tmp4 = X[0];
tmp21 = Y[-2 * iostride];
{
fftw_real tmp6;
fftw_real tmp8;
fftw_real tmp5;
fftw_real tmp7;
ASSERT_ALIGNED_DOUBLE;
tmp6 = X[iostride];
tmp8 = Y[-iostride];
tmp5 = c_re(W[0]);
tmp7 = c_im(W[0]);
tmp9 = (tmp5 * tmp6) - (tmp7 * tmp8);
tmp17 = (tmp7 * tmp6) + (tmp5 * tmp8);
}
{
fftw_real tmp11;
fftw_real tmp13;
fftw_real tmp10;
fftw_real tmp12;
ASSERT_ALIGNED_DOUBLE;
tmp11 = X[2 * iostride];
tmp13 = Y[0];
tmp10 = c_re(W[1]);
tmp12 = c_im(W[1]);
tmp14 = (tmp10 * tmp11) - (tmp12 * tmp13);
tmp18 = (tmp12 * tmp11) + (tmp10 * tmp13);
}
tmp15 = tmp9 + tmp14;
tmp20 = tmp17 + tmp18;
{
fftw_real tmp16;
fftw_real tmp19;
fftw_real tmp22;
fftw_real tmp23;
ASSERT_ALIGNED_DOUBLE;
X[0] = tmp4 + tmp15;
tmp16 = tmp4 - (K500000000 * tmp15);
tmp19 = K866025403 * (tmp17 - tmp18);
Y[-2 * iostride] = tmp16 - tmp19;
X[iostride] = tmp16 + tmp19;
Y[0] = tmp20 + tmp21;
tmp22 = tmp21 - (K500000000 * tmp20);
tmp23 = K866025403 * (tmp14 - tmp9);
X[2 * iostride] = -(tmp22 - tmp23);
Y[-iostride] = tmp23 + tmp22;
}
}
if (i == m) {
fftw_real tmp1;
fftw_real tmp3;
fftw_real tmp2;
ASSERT_ALIGNED_DOUBLE;
tmp1 = X[iostride];
tmp3 = X[0];
tmp2 = X[2 * iostride];
Y[0] = -(K866025403 * (tmp1 + tmp2));
X[iostride] = tmp2 + tmp3 - tmp1;
X[0] = tmp3 - (K500000000 * (tmp2 - tmp1));
}
}
void fftw_no_twiddle_14(const fftw_complex *input, fftw_complex *output, int istride, int ostride)
{
fftw_real tmp3;
fftw_real tmp25;
fftw_real tmp68;
fftw_real tmp77;
fftw_real tmp10;
fftw_real tmp62;
fftw_real tmp28;
fftw_real tmp88;
fftw_real tmp42;
fftw_real tmp71;
fftw_real tmp80;
fftw_real tmp97;
fftw_real tmp17;
fftw_real tmp64;
fftw_real tmp31;
fftw_real tmp90;
fftw_real tmp56;
fftw_real tmp69;
fftw_real tmp86;
fftw_real tmp99;
fftw_real tmp24;
fftw_real tmp63;
fftw_real tmp34;
fftw_real tmp89;
fftw_real tmp49;
fftw_real tmp70;
fftw_real tmp83;
fftw_real tmp98;
ASSERT_ALIGNED_DOUBLE;
{
fftw_real tmp1;
fftw_real tmp2;
fftw_real tmp66;
fftw_real tmp67;
ASSERT_ALIGNED_DOUBLE;
tmp1 = c_re(input[0]);
tmp2 = c_re(input[7 * istride]);
tmp3 = tmp1 - tmp2;
tmp25 = tmp1 + tmp2;
tmp66 = c_im(input[0]);
tmp67 = c_im(input[7 * istride]);
tmp68 = tmp66 - tmp67;
tmp77 = tmp66 + tmp67;
}
{
fftw_real tmp6;
fftw_real tmp26;
fftw_real tmp9;
fftw_real tmp27;
ASSERT_ALIGNED_DOUBLE;
{
fftw_real tmp4;
fftw_real tmp5;
fftw_real tmp7;
fftw_real tmp8;
ASSERT_ALIGNED_DOUBLE;
tmp4 = c_re(input[2 * istride]);
tmp5 = c_re(input[9 * istride]);
tmp6 = tmp4 - tmp5;
tmp26 = tmp4 + tmp5;
tmp7 = c_re(input[12 * istride]);
tmp8 = c_re(input[5 * istride]);
tmp9 = tmp7 - tmp8;
tmp27 = tmp7 + tmp8;
}
tmp10 = tmp6 + tmp9;
tmp62 = tmp9 - tmp6;
tmp28 = tmp26 + tmp27;
tmp88 = tmp27 - tmp26;
}
{
fftw_real tmp38;
fftw_real tmp78;
fftw_real tmp41;
fftw_real tmp79;
ASSERT_ALIGNED_DOUBLE;
{
fftw_real tmp36;
fftw_real tmp37;
fftw_real tmp39;
fftw_real tmp40;
ASSERT_ALIGNED_DOUBLE;
tmp36 = c_im(input[2 * istride]);
tmp37 = c_im(input[9 * istride]);
tmp38 = tmp36 - tmp37;
tmp78 = tmp36 + tmp37;
tmp39 = c_im(input[12 * istride]);
tmp40 = c_im(input[5 * istride]);
tmp41 = tmp39 - tmp40;
tmp79 = tmp39 + tmp40;
}
tmp42 = tmp38 - tmp41;
tmp71 = tmp38 + tmp41;
tmp80 = tmp78 + tmp79;
tmp97 = tmp78 - tmp79;
}
{
fftw_real tmp13;
fftw_real tmp29;
fftw_real tmp16;
fftw_real tmp30;
ASSERT_ALIGNED_DOUBLE;
{
fftw_real tmp11;
fftw_real tmp12;
fftw_real tmp14;
fftw_real tmp15;
ASSERT_ALIGNED_DOUBLE;
tmp11 = c_re(input[4 * istride]);
tmp12 = c_re(input[11 * istride]);
tmp13 = tmp11 - tmp12;
tmp29 = tmp11 + tmp12;
tmp14 = c_re(input[10 * istride]);
tmp15 = c_re(input[3 * istride]);
tmp16 = tmp14 - tmp15;
tmp30 = tmp14 + tmp15;
}
tmp17 = tmp13 + tmp16;
tmp64 = tmp16 - tmp13;
tmp31 = tmp29 + tmp30;
tmp90 = tmp29 - tmp30;
}
{
fftw_real tmp52;
fftw_real tmp84;
fftw_real tmp55;
fftw_real tmp85;
ASSERT_ALIGNED_DOUBLE;
{
fftw_real tmp50;
fftw_real tmp51;
fftw_real tmp53;
fftw_real tmp54;
ASSERT_ALIGNED_DOUBLE;
tmp50 = c_im(input[4 * istride]);
tmp51 = c_im(input[11 * istride]);
tmp52 = tmp50 - tmp51;
tmp84 = tmp50 + tmp51;
tmp53 = c_im(input[10 * istride]);
tmp54 = c_im(input[3 * istride]);
tmp55 = tmp53 - tmp54;
tmp85 = tmp53 + tmp54;
}
tmp56 = tmp52 - tmp55;
tmp69 = tmp52 + tmp55;
tmp86 = tmp84 + tmp85;
tmp99 = tmp85 - tmp84;
}
{
fftw_real tmp20;
fftw_real tmp32;
fftw_real tmp23;
fftw_real tmp33;
ASSERT_ALIGNED_DOUBLE;
{
fftw_real tmp18;
fftw_real tmp19;
fftw_real tmp21;
fftw_real tmp22;
ASSERT_ALIGNED_DOUBLE;
tmp18 = c_re(input[6 * istride]);
tmp19 = c_re(input[13 * istride]);
tmp20 = tmp18 - tmp19;
tmp32 = tmp18 + tmp19;
tmp21 = c_re(input[8 * istride]);
tmp22 = c_re(input[istride]);
tmp23 = tmp21 - tmp22;
tmp33 = tmp21 + tmp22;
}
tmp24 = tmp20 + tmp23;
tmp63 = tmp23 - tmp20;
tmp34 = tmp32 + tmp33;
tmp89 = tmp32 - tmp33;
}
{
fftw_real tmp45;
fftw_real tmp81;
fftw_real tmp48;
fftw_real tmp82;
ASSERT_ALIGNED_DOUBLE;
{
fftw_real tmp43;
fftw_real tmp44;
fftw_real tmp46;
fftw_real tmp47;
ASSERT_ALIGNED_DOUBLE;
tmp43 = c_im(input[6 * istride]);
tmp44 = c_im(input[13 * istride]);
tmp45 = tmp43 - tmp44;
tmp81 = tmp43 + tmp44;
tmp46 = c_im(input[8 * istride]);
tmp47 = c_im(input[istride]);
tmp48 = tmp46 - tmp47;
tmp82 = tmp46 + tmp47;
}
tmp49 = tmp45 - tmp48;
tmp70 = tmp45 + tmp48;
tmp83 = tmp81 + tmp82;
tmp98 = tmp82 - tmp81;
}
{
fftw_real tmp57;
fftw_real tmp35;
fftw_real tmp100;
fftw_real tmp96;
ASSERT_ALIGNED_DOUBLE;
c_re(output[7 * ostride]) = tmp3 + tmp10 + tmp17 + tmp24;
tmp57 = (K974927912 * tmp42) - (K781831482 * tmp49) - (K433883739 * tmp56);
tmp35 = tmp3 + (K623489801 * tmp24) - (K900968867 * tmp17) - (K222520933 * tmp10);
c_re(output[5 * ostride]) = tmp35 - tmp57;
c_re(output[9 * ostride]) = tmp35 + tmp57;
{
fftw_real tmp59;
fftw_real tmp58;
fftw_real tmp61;
fftw_real tmp60;
ASSERT_ALIGNED_DOUBLE;
tmp59 = (K781831482 * tmp42) + (K974927912 * tmp56) + (K433883739 * tmp49);
tmp58 = tmp3 + (K623489801 * tmp10) - (K900968867 * tmp24) - (K222520933 * tmp17);
c_re(output[13 * ostride]) = tmp58 - tmp59;
c_re(output[ostride]) = tmp58 + tmp59;
tmp61 = (K433883739 * tmp42) + (K974927912 * tmp49) - (K781831482 * tmp56);
tmp60 = tmp3 + (K623489801 * tmp17) - (K222520933 * tmp24) - (K900968867 * tmp10);
c_re(output[11 * ostride]) = tmp60 - tmp61;
c_re(output[3 * ostride]) = tmp60 + tmp61;
}
c_re(output[0]) = tmp25 + tmp28 + tmp31 + tmp34;
tmp100 = (K781831482 * tmp97) - (K433883739 * tmp98) - (K974927912 * tmp99);
tmp96 = tmp25 + (K623489801 * tmp28) - (K900968867 * tmp34) - (K222520933 * tmp31);
c_re(output[6 * ostride]) = tmp96 - tmp100;
c_re(output[8 * ostride]) = tmp96 + tmp100;
{
fftw_real tmp102;
fftw_real tmp101;
fftw_real tmp104;
fftw_real tmp103;
ASSERT_ALIGNED_DOUBLE;
tmp102 = (K433883739 * tmp97) + (K781831482 * tmp99) - (K974927912 * tmp98);
tmp101 = tmp25 + (K623489801 * tmp31) - (K222520933 * tmp34) - (K900968867 * tmp28);
c_re(output[4 * ostride]) = tmp101 - tmp102;
c_re(output[10 * ostride]) = tmp101 + tmp102;
tmp104 = (K974927912 * tmp97) + (K433883739 * tmp99) + (K781831482 * tmp98);
tmp103 = tmp25 + (K623489801 * tmp34) - (K900968867 * tmp31) - (K222520933 * tmp28);
c_re(output[12 * ostride]) = tmp103 - tmp104;
c_re(output[2 * ostride]) = tmp103 + tmp104;
}
}
{
fftw_real tmp76;
fftw_real tmp75;
fftw_real tmp94;
fftw_real tmp95;
ASSERT_ALIGNED_DOUBLE;
c_im(output[7 * ostride]) = tmp68 + tmp71 + tmp69 + tmp70;
tmp76 = (K974927912 * tmp62) - (K781831482 * tmp63) - (K433883739 * tmp64);
tmp75 = tmp68 + (K623489801 * tmp70) - (K900968867 * tmp69) - (K222520933 * tmp71);
c_im(output[5 * ostride]) = tmp75 - tmp76;
c_im(output[9 * ostride]) = tmp76 + tmp75;
{
fftw_real tmp73;
fftw_real tmp74;
fftw_real tmp65;
fftw_real tmp72;
ASSERT_ALIGNED_DOUBLE;
tmp73 = (K781831482 * tmp62) + (K974927912 * tmp64) + (K433883739 * tmp63);
tmp74 = tmp68 + (K623489801 * tmp71) - (K900968867 * tmp70) - (K222520933 * tmp69);
c_im(output[ostride]) = tmp73 + tmp74;
c_im(output[13 * ostride]) = tmp74 - tmp73;
tmp65 = (K433883739 * tmp62) + (K974927912 * tmp63) - (K781831482 * tmp64);
tmp72 = tmp68 + (K623489801 * tmp69) - (K222520933 * tmp70) - (K900968867 * tmp71);
c_im(output[3 * ostride]) = tmp65 + tmp72;
c_im(output[11 * ostride]) = tmp72 - tmp65;
}
c_im(output[0]) = tmp77 + tmp80 + tmp86 + tmp83;
tmp94 = (K974927912 * tmp88) + (K433883739 * tmp90) + (K781831482 * tmp89);
tmp95 = tmp77 + (K623489801 * tmp83) - (K900968867 * tmp86) - (K222520933 * tmp80);
c_im(output[2 * ostride]) = tmp94 + tmp95;
c_im(output[12 * ostride]) = tmp95 - tmp94;
{
fftw_real tmp91;
fftw_real tmp87;
fftw_real tmp93;
fftw_real tmp92;
ASSERT_ALIGNED_DOUBLE;
tmp91 = (K781831482 * tmp88) - (K433883739 * tmp89) - (K974927912 * tmp90);
tmp87 = tmp77 + (K623489801 * tmp80) - (K900968867 * tmp83) - (K222520933 * tmp86);
c_im(output[6 * ostride]) = tmp87 - tmp91;
c_im(output[8 * ostride]) = tmp91 + tmp87;
tmp93 = (K433883739 * tmp88) + (K781831482 * tmp90) - (K974927912 * tmp89);
tmp92 = tmp77 + (K623489801 * tmp86) - (K222520933 * tmp83) - (K900968867 * tmp80);
c_im(output[4 * ostride]) = tmp92 - tmp93;
c_im(output[10 * ostride]) = tmp93 + tmp92;
}
}
}
void fftw_hc2hc_backward_16(fftw_real *A, const fftw_complex *W, int iostride, int m, int dist)
{
int i;
fftw_real *X;
fftw_real *Y;
X = A;
Y = A + (16 * iostride);
{
fftw_real tmp279;
fftw_real tmp324;
fftw_real tmp312;
fftw_real tmp299;
fftw_real tmp276;
fftw_real tmp296;
fftw_real tmp309;
fftw_real tmp323;
fftw_real tmp283;
fftw_real tmp291;
fftw_real tmp286;
fftw_real tmp294;
fftw_real tmp301;
fftw_real tmp319;
fftw_real tmp327;
fftw_real tmp326;
fftw_real tmp316;
fftw_real tmp302;
ASSERT_ALIGNED_DOUBLE;
{
fftw_real tmp277;
fftw_real tmp278;
fftw_real tmp310;
fftw_real tmp297;
fftw_real tmp298;
fftw_real tmp311;
ASSERT_ALIGNED_DOUBLE;
tmp277 = X[2 * iostride];
tmp278 = X[6 * iostride];
tmp310 = tmp277 - tmp278;
tmp297 = Y[-2 * iostride];
tmp298 = Y[-6 * iostride];
tmp311 = tmp298 + tmp297;
tmp279 = K2_000000000 * (tmp277 + tmp278);
tmp324 = K1_414213562 * (tmp310 + tmp311);
tmp312 = K1_414213562 * (tmp310 - tmp311);
tmp299 = K2_000000000 * (tmp297 - tmp298);
}
{
fftw_real tmp275;
fftw_real tmp308;
fftw_real tmp273;
fftw_real tmp306;
ASSERT_ALIGNED_DOUBLE;
{
fftw_real tmp274;
fftw_real tmp307;
fftw_real tmp271;
fftw_real tmp272;
ASSERT_ALIGNED_DOUBLE;
tmp274 = X[4 * iostride];
tmp275 = K2_000000000 * tmp274;
tmp307 = Y[-4 * iostride];
tmp308 = K2_000000000 * tmp307;
tmp271 = X[0];
tmp272 = X[8 * iostride];
tmp273 = tmp271 + tmp272;
tmp306 = tmp271 - tmp272;
}
tmp276 = tmp273 + tmp275;
tmp296 = tmp273 - tmp275;
tmp309 = tmp306 - tmp308;
tmp323 = tmp306 + tmp308;
}
{
fftw_real tmp314;
fftw_real tmp318;
fftw_real tmp317;
fftw_real tmp315;
ASSERT_ALIGNED_DOUBLE;
{
fftw_real tmp281;
fftw_real tmp282;
fftw_real tmp289;
fftw_real tmp290;
ASSERT_ALIGNED_DOUBLE;
tmp281 = X[iostride];
tmp282 = X[7 * iostride];
tmp283 = tmp281 + tmp282;
tmp314 = tmp281 - tmp282;
tmp289 = Y[-iostride];
tmp290 = Y[-7 * iostride];
tmp291 = tmp289 - tmp290;
tmp318 = tmp289 + tmp290;
}
{
fftw_real tmp284;
fftw_real tmp285;
fftw_real tmp292;
fftw_real tmp293;
ASSERT_ALIGNED_DOUBLE;
tmp284 = X[3 * iostride];
tmp285 = X[5 * iostride];
tmp286 = tmp284 + tmp285;
tmp317 = tmp285 - tmp284;
tmp292 = Y[-3 * iostride];
tmp293 = Y[-5 * iostride];
tmp294 = tmp292 - tmp293;
tmp315 = tmp293 + tmp292;
}
tmp301 = tmp283 - tmp286;
tmp319 = tmp317 + tmp318;
tmp327 = tmp318 - tmp317;
tmp326 = tmp314 + tmp315;
tmp316 = tmp314 - tmp315;
tmp302 = tmp294 + tmp291;
}
{
fftw_real tmp280;
fftw_real tmp287;
fftw_real tmp288;
fftw_real tmp295;
ASSERT_ALIGNED_DOUBLE;
tmp280 = tmp276 + tmp279;
tmp287 = K2_000000000 * (tmp283 + tmp286);
X[8 * iostride] = tmp280 - tmp287;
X[0] = tmp280 + tmp287;
tmp288 = tmp276 - tmp279;
tmp295 = K2_000000000 * (tmp291 - tmp294);
X[12 * iostride] = tmp288 + tmp295;
X[4 * iostride] = tmp288 - tmp295;
}
{
fftw_real tmp300;
fftw_real tmp303;
fftw_real tmp304;
fftw_real tmp305;
ASSERT_ALIGNED_DOUBLE;
tmp300 = tmp296 - tmp299;
tmp303 = K1_414213562 * (tmp301 - tmp302);
X[10 * iostride] = tmp300 - tmp303;
X[2 * iostride] = tmp300 + tmp303;
tmp304 = tmp296 + tmp299;
tmp305 = K1_414213562 * (tmp301 + tmp302);
X[6 * iostride] = tmp304 - tmp305;
X[14 * iostride] = tmp304 + tmp305;
}
{
fftw_real tmp313;
fftw_real tmp320;
fftw_real tmp321;
fftw_real tmp322;
ASSERT_ALIGNED_DOUBLE;
tmp313 = tmp309 + tmp312;
tmp320 = (K1_847759065 * tmp316) - (K765366864 * tmp319);
X[9 * iostride] = tmp313 - tmp320;
X[iostride] = tmp313 + tmp320;
tmp321 = tmp309 - tmp312;
tmp322 = (K765366864 * tmp316) + (K1_847759065 * tmp319);
X[5 * iostride] = tmp321 - tmp322;
X[13 * iostride] = tmp321 + tmp322;
}
{
fftw_real tmp325;
fftw_real tmp328;
fftw_real tmp329;
fftw_real tmp330;
ASSERT_ALIGNED_DOUBLE;
tmp325 = tmp323 - tmp324;
tmp328 = (K765366864 * tmp326) - (K1_847759065 * tmp327);
X[11 * iostride] = tmp325 - tmp328;
X[3 * iostride] = tmp325 + tmp328;
tmp329 = tmp323 + tmp324;
tmp330 = (K1_847759065 * tmp326) + (K765366864 * tmp327);
X[7 * iostride] = tmp329 - tmp330;
X[15 * iostride] = tmp329 + tmp330;
}
}
X = X + dist;
Y = Y - dist;
for (i = 2; i < m; i = i + 2, X = X + dist, Y = Y - dist, W = W + 15) {
fftw_real tmp73;
fftw_real tmp98;
fftw_real tmp135;
fftw_real tmp160;
fftw_real tmp182;
fftw_real tmp236;
fftw_real tmp210;
fftw_real tmp248;
fftw_real tmp95;
fftw_real tmp124;
fftw_real tmp138;
fftw_real tmp164;
fftw_real tmp197;
fftw_real tmp216;
fftw_real tmp244;
fftw_real tmp252;
fftw_real tmp80;
fftw_real tmp128;
fftw_real tmp105;
fftw_real tmp161;
fftw_real tmp213;
fftw_real tmp237;
fftw_real tmp189;
fftw_real tmp249;
fftw_real tmp88;
fftw_real tmp115;
fftw_real tmp137;
fftw_real tmp163;
fftw_real tmp204;
fftw_real tmp215;
fftw_real tmp241;
fftw_real tmp251;
ASSERT_ALIGNED_DOUBLE;
{
fftw_real tmp69;
fftw_real tmp180;
fftw_real tmp131;
fftw_real tmp209;
fftw_real tmp72;
fftw_real tmp208;
fftw_real tmp134;
fftw_real tmp181;
ASSERT_ALIGNED_DOUBLE;
{
fftw_real tmp67;
fftw_real tmp68;
fftw_real tmp129;
fftw_real tmp130;
ASSERT_ALIGNED_DOUBLE;
tmp67 = X[0];
tmp68 = Y[-8 * iostride];
tmp69 = tmp67 + tmp68;
tmp180 = tmp67 - tmp68;
tmp129 = Y[0];
tmp130 = X[8 * iostride];
tmp131 = tmp129 - tmp130;
tmp209 = tmp129 + tmp130;
}
{
fftw_real tmp70;
fftw_real tmp71;
fftw_real tmp132;
fftw_real tmp133;
ASSERT_ALIGNED_DOUBLE;
tmp70 = X[4 * iostride];
tmp71 = Y[-12 * iostride];
tmp72 = tmp70 + tmp71;
tmp208 = tmp70 - tmp71;
tmp132 = Y[-4 * iostride];
tmp133 = X[12 * iostride];
tmp134 = tmp132 - tmp133;
tmp181 = tmp132 + tmp133;
}
tmp73 = tmp69 + tmp72;
tmp98 = tmp69 - tmp72;
tmp135 = tmp131 - tmp134;
tmp160 = tmp131 + tmp134;
tmp182 = tmp180 - tmp181;
tmp236 = tmp180 + tmp181;
tmp210 = tmp208 + tmp209;
tmp248 = tmp209 - tmp208;
}
{
fftw_real tmp91;
fftw_real tmp194;
fftw_real tmp119;
fftw_real tmp192;
fftw_real tmp94;
fftw_real tmp191;
fftw_real tmp122;
fftw_real tmp195;
fftw_real tmp116;
fftw_real tmp123;
ASSERT_ALIGNED_DOUBLE;
{
fftw_real tmp89;
fftw_real tmp90;
fftw_real tmp117;
fftw_real tmp118;
ASSERT_ALIGNED_DOUBLE;
tmp89 = Y[-15 * iostride];
tmp90 = X[7 * iostride];
tmp91 = tmp89 + tmp90;
tmp194 = tmp89 - tmp90;
tmp117 = Y[-7 * iostride];
tmp118 = X[15 * iostride];
tmp119 = tmp117 - tmp118;
tmp192 = tmp117 + tmp118;
}
{
fftw_real tmp92;
fftw_real tmp93;
fftw_real tmp120;
fftw_real tmp121;
ASSERT_ALIGNED_DOUBLE;
tmp92 = X[3 * iostride];
tmp93 = Y[-11 * iostride];
tmp94 = tmp92 + tmp93;
tmp191 = tmp92 - tmp93;
tmp120 = Y[-3 * iostride];
tmp121 = X[11 * iostride];
tmp122 = tmp120 - tmp121;
tmp195 = tmp120 + tmp121;
}
tmp95 = tmp91 + tmp94;
tmp116 = tmp91 - tmp94;
tmp123 = tmp119 - tmp122;
tmp124 = tmp116 + tmp123;
tmp138 = tmp123 - tmp116;
tmp164 = tmp119 + tmp122;
{
fftw_real tmp193;
fftw_real tmp196;
fftw_real tmp242;
fftw_real tmp243;
ASSERT_ALIGNED_DOUBLE;
tmp193 = tmp191 - tmp192;
tmp196 = tmp194 - tmp195;
tmp197 = (K923879532 * tmp193) - (K382683432 * tmp196);
tmp216 = (K382683432 * tmp193) + (K923879532 * tmp196);
tmp242 = tmp194 + tmp195;
tmp243 = tmp191 + tmp192;
tmp244 = (K382683432 * tmp242) - (K923879532 * tmp243);
tmp252 = (K382683432 * tmp243) + (K923879532 * tmp242);
}
}
{
fftw_real tmp76;
fftw_real tmp183;
fftw_real tmp104;
fftw_real tmp184;
fftw_real tmp79;
fftw_real tmp186;
fftw_real tmp101;
fftw_real tmp187;
ASSERT_ALIGNED_DOUBLE;
{
fftw_real tmp74;
fftw_real tmp75;
fftw_real tmp102;
fftw_real tmp103;
ASSERT_ALIGNED_DOUBLE;
tmp74 = X[2 * iostride];
tmp75 = Y[-10 * iostride];
tmp76 = tmp74 + tmp75;
tmp183 = tmp74 - tmp75;
tmp102 = Y[-2 * iostride];
tmp103 = X[10 * iostride];
tmp104 = tmp102 - tmp103;
tmp184 = tmp102 + tmp103;
}
{
fftw_real tmp77;
fftw_real tmp78;
fftw_real tmp99;
fftw_real tmp100;
ASSERT_ALIGNED_DOUBLE;
tmp77 = Y[-14 * iostride];
tmp78 = X[6 * iostride];
tmp79 = tmp77 + tmp78;
tmp186 = tmp77 - tmp78;
tmp99 = Y[-6 * iostride];
tmp100 = X[14 * iostride];
tmp101 = tmp99 - tmp100;
tmp187 = tmp99 + tmp100;
}
tmp80 = tmp76 + tmp79;
tmp128 = tmp76 - tmp79;
tmp105 = tmp101 - tmp104;
tmp161 = tmp104 + tmp101;
{
fftw_real tmp211;
fftw_real tmp212;
fftw_real tmp185;
fftw_real tmp188;
ASSERT_ALIGNED_DOUBLE;
tmp211 = tmp183 + tmp184;
tmp212 = tmp186 + tmp187;
tmp213 = K707106781 * (tmp211 - tmp212);
tmp237 = K707106781 * (tmp211 + tmp212);
tmp185 = tmp183 - tmp184;
tmp188 = tmp186 - tmp187;
tmp189 = K707106781 * (tmp185 + tmp188);
tmp249 = K707106781 * (tmp185 - tmp188);
}
}
{
fftw_real tmp84;
fftw_real tmp201;
fftw_real tmp110;
fftw_real tmp199;
fftw_real tmp87;
fftw_real tmp198;
fftw_real tmp113;
fftw_real tmp202;
fftw_real tmp107;
fftw_real tmp114;
ASSERT_ALIGNED_DOUBLE;
{
fftw_real tmp82;
fftw_real tmp83;
fftw_real tmp108;
fftw_real tmp109;
ASSERT_ALIGNED_DOUBLE;
tmp82 = X[iostride];
tmp83 = Y[-9 * iostride];
tmp84 = tmp82 + tmp83;
tmp201 = tmp82 - tmp83;
tmp108 = Y[-iostride];
tmp109 = X[9 * iostride];
tmp110 = tmp108 - tmp109;
tmp199 = tmp108 + tmp109;
}
{
fftw_real tmp85;
fftw_real tmp86;
fftw_real tmp111;
fftw_real tmp112;
ASSERT_ALIGNED_DOUBLE;
tmp85 = X[5 * iostride];
tmp86 = Y[-13 * iostride];
tmp87 = tmp85 + tmp86;
tmp198 = tmp85 - tmp86;
tmp111 = Y[-5 * iostride];
tmp112 = X[13 * iostride];
tmp113 = tmp111 - tmp112;
tmp202 = tmp111 + tmp112;
}
tmp88 = tmp84 + tmp87;
tmp107 = tmp84 - tmp87;
tmp114 = tmp110 - tmp113;
tmp115 = tmp107 - tmp114;
tmp137 = tmp107 + tmp114;
tmp163 = tmp110 + tmp113;
{
fftw_real tmp200;
fftw_real tmp203;
fftw_real tmp239;
fftw_real tmp240;
ASSERT_ALIGNED_DOUBLE;
tmp200 = tmp198 + tmp199;
tmp203 = tmp201 - tmp202;
tmp204 = (K923879532 * tmp200) + (K382683432 * tmp203);
tmp215 = (K923879532 * tmp203) - (K382683432 * tmp200);
tmp239 = tmp201 + tmp202;
tmp240 = tmp199 - tmp198;
tmp241 = (K382683432 * tmp239) - (K923879532 * tmp240);
tmp251 = (K382683432 * tmp240) + (K923879532 * tmp239);
}
}
{
fftw_real tmp81;
fftw_real tmp96;
fftw_real tmp158;
fftw_real tmp162;
fftw_real tmp165;
fftw_real tmp166;
fftw_real tmp157;
fftw_real tmp159;
ASSERT_ALIGNED_DOUBLE;
tmp81 = tmp73 + tmp80;
tmp96 = tmp88 + tmp95;
tmp158 = tmp81 - tmp96;
tmp162 = tmp160 + tmp161;
tmp165 = tmp163 + tmp164;
tmp166 = tmp162 - tmp165;
X[0] = tmp81 + tmp96;
Y[-15 * iostride] = tmp162 + tmp165;
tmp157 = c_re(W[7]);
tmp159 = c_im(W[7]);
X[8 * iostride] = (tmp157 * tmp158) + (tmp159 * tmp166);
Y[-7 * iostride] = (tmp157 * tmp166) - (tmp159 * tmp158);
}
{
fftw_real tmp170;
fftw_real tmp176;
fftw_real tmp174;
fftw_real tmp178;
ASSERT_ALIGNED_DOUBLE;
{
fftw_real tmp168;
fftw_real tmp169;
fftw_real tmp172;
fftw_real tmp173;
ASSERT_ALIGNED_DOUBLE;
tmp168 = tmp160 - tmp161;
tmp169 = tmp88 - tmp95;
tmp170 = tmp168 - tmp169;
tmp176 = tmp169 + tmp168;
tmp172 = tmp73 - tmp80;
tmp173 = tmp164 - tmp163;
tmp174 = tmp172 - tmp173;
tmp178 = tmp172 + tmp173;
}
{
fftw_real tmp167;
fftw_real tmp171;
fftw_real tmp175;
fftw_real tmp177;
ASSERT_ALIGNED_DOUBLE;
tmp167 = c_re(W[11]);
tmp171 = c_im(W[11]);
Y[-3 * iostride] = (tmp167 * tmp170) - (tmp171 * tmp174);
X[12 * iostride] = (tmp171 * tmp170) + (tmp167 * tmp174);
tmp175 = c_re(W[3]);
tmp177 = c_im(W[3]);
Y[-11 * iostride] = (tmp175 * tmp176) - (tmp177 * tmp178);
X[4 * iostride] = (tmp177 * tmp176) + (tmp175 * tmp178);
}
}
{
fftw_real tmp126;
fftw_real tmp142;
fftw_real tmp140;
fftw_real tmp144;
ASSERT_ALIGNED_DOUBLE;
{
fftw_real tmp106;
fftw_real tmp125;
fftw_real tmp136;
fftw_real tmp139;
ASSERT_ALIGNED_DOUBLE;
tmp106 = tmp98 + tmp105;
tmp125 = K707106781 * (tmp115 + tmp124);
tmp126 = tmp106 - tmp125;
tmp142 = tmp106 + tmp125;
tmp136 = tmp128 + tmp135;
tmp139 = K707106781 * (tmp137 + tmp138);
tmp140 = tmp136 - tmp139;
tmp144 = tmp136 + tmp139;
}
{
fftw_real tmp97;
fftw_real tmp127;
fftw_real tmp141;
fftw_real tmp143;
ASSERT_ALIGNED_DOUBLE;
tmp97 = c_re(W[9]);
tmp127 = c_im(W[9]);
X[10 * iostride] = (tmp97 * tmp126) + (tmp127 * tmp140);
Y[-5 * iostride] = (tmp97 * tmp140) - (tmp127 * tmp126);
tmp141 = c_re(W[1]);
tmp143 = c_im(W[1]);
X[2 * iostride] = (tmp141 * tmp142) + (tmp143 * tmp144);
Y[-13 * iostride] = (tmp141 * tmp144) - (tmp143 * tmp142);
}
}
{
fftw_real tmp148;
fftw_real tmp154;
fftw_real tmp152;
fftw_real tmp156;
ASSERT_ALIGNED_DOUBLE;
{
fftw_real tmp146;
fftw_real tmp147;
fftw_real tmp150;
fftw_real tmp151;
ASSERT_ALIGNED_DOUBLE;
tmp146 = tmp135 - tmp128;
tmp147 = K707106781 * (tmp115 - tmp124);
tmp148 = tmp146 - tmp147;
tmp154 = tmp146 + tmp147;
tmp150 = tmp98 - tmp105;
tmp151 = K707106781 * (tmp138 - tmp137);
tmp152 = tmp150 - tmp151;
tmp156 = tmp150 + tmp151;
}
{
fftw_real tmp145;
fftw_real tmp149;
fftw_real tmp153;
fftw_real tmp155;
ASSERT_ALIGNED_DOUBLE;
tmp145 = c_re(W[13]);
tmp149 = c_im(W[13]);
Y[-iostride] = (tmp145 * tmp148) - (tmp149 * tmp152);
X[14 * iostride] = (tmp149 * tmp148) + (tmp145 * tmp152);
tmp153 = c_re(W[5]);
tmp155 = c_im(W[5]);
Y[-9 * iostride] = (tmp153 * tmp154) - (tmp155 * tmp156);
X[6 * iostride] = (tmp155 * tmp154) + (tmp153 * tmp156);
}
}
{
fftw_real tmp206;
fftw_real tmp220;
fftw_real tmp218;
fftw_real tmp222;
ASSERT_ALIGNED_DOUBLE;
{
fftw_real tmp190;
fftw_real tmp205;
fftw_real tmp214;
fftw_real tmp217;
ASSERT_ALIGNED_DOUBLE;
tmp190 = tmp182 - tmp189;
tmp205 = tmp197 - tmp204;
tmp206 = tmp190 - tmp205;
tmp220 = tmp190 + tmp205;
tmp214 = tmp210 - tmp213;
tmp217 = tmp215 - tmp216;
tmp218 = tmp214 - tmp217;
tmp222 = tmp214 + tmp217;
}
{
fftw_real tmp179;
fftw_real tmp207;
fftw_real tmp219;
fftw_real tmp221;
ASSERT_ALIGNED_DOUBLE;
tmp179 = c_re(W[12]);
tmp207 = c_im(W[12]);
X[13 * iostride] = (tmp179 * tmp206) + (tmp207 * tmp218);
Y[-2 * iostride] = (tmp179 * tmp218) - (tmp207 * tmp206);
tmp219 = c_re(W[4]);
tmp221 = c_im(W[4]);
X[5 * iostride] = (tmp219 * tmp220) + (tmp221 * tmp222);
Y[-10 * iostride] = (tmp219 * tmp222) - (tmp221 * tmp220);
}
}
{
fftw_real tmp226;
fftw_real tmp232;
fftw_real tmp230;
fftw_real tmp234;
ASSERT_ALIGNED_DOUBLE;
{
fftw_real tmp224;
fftw_real tmp225;
fftw_real tmp228;
fftw_real tmp229;
ASSERT_ALIGNED_DOUBLE;
tmp224 = tmp210 + tmp213;
tmp225 = tmp204 + tmp197;
tmp226 = tmp224 - tmp225;
tmp232 = tmp224 + tmp225;
tmp228 = tmp182 + tmp189;
tmp229 = tmp215 + tmp216;
tmp230 = tmp228 - tmp229;
tmp234 = tmp228 + tmp229;
}
{
fftw_real tmp223;
fftw_real tmp227;
fftw_real tmp231;
fftw_real tmp233;
ASSERT_ALIGNED_DOUBLE;
tmp223 = c_re(W[8]);
tmp227 = c_im(W[8]);
Y[-6 * iostride] = (tmp223 * tmp226) - (tmp227 * tmp230);
X[9 * iostride] = (tmp227 * tmp226) + (tmp223 * tmp230);
tmp231 = c_re(W[0]);
tmp233 = c_im(W[0]);
Y[-14 * iostride] = (tmp231 * tmp232) - (tmp233 * tmp234);
X[iostride] = (tmp233 * tmp232) + (tmp231 * tmp234);
}
}
{
fftw_real tmp246;
fftw_real tmp256;
fftw_real tmp254;
fftw_real tmp258;
ASSERT_ALIGNED_DOUBLE;
{
fftw_real tmp238;
fftw_real tmp245;
fftw_real tmp250;
fftw_real tmp253;
ASSERT_ALIGNED_DOUBLE;
tmp238 = tmp236 - tmp237;
tmp245 = tmp241 + tmp244;
tmp246 = tmp238 - tmp245;
tmp256 = tmp238 + tmp245;
tmp250 = tmp248 + tmp249;
tmp253 = tmp251 - tmp252;
tmp254 = tmp250 - tmp253;
tmp258 = tmp250 + tmp253;
}
{
fftw_real tmp235;
fftw_real tmp247;
fftw_real tmp255;
fftw_real tmp257;
ASSERT_ALIGNED_DOUBLE;
tmp235 = c_re(W[10]);
tmp247 = c_im(W[10]);
X[11 * iostride] = (tmp235 * tmp246) + (tmp247 * tmp254);
Y[-4 * iostride] = (tmp235 * tmp254) - (tmp247 * tmp246);
tmp255 = c_re(W[2]);
tmp257 = c_im(W[2]);
X[3 * iostride] = (tmp255 * tmp256) + (tmp257 * tmp258);
Y[-12 * iostride] = (tmp255 * tmp258) - (tmp257 * tmp256);
}
}
{
fftw_real tmp262;
fftw_real tmp268;
fftw_real tmp266;
fftw_real tmp270;
ASSERT_ALIGNED_DOUBLE;
{
fftw_real tmp260;
fftw_real tmp261;
fftw_real tmp264;
fftw_real tmp265;
ASSERT_ALIGNED_DOUBLE;
tmp260 = tmp248 - tmp249;
tmp261 = tmp241 - tmp244;
tmp262 = tmp260 + tmp261;
tmp268 = tmp260 - tmp261;
tmp264 = tmp236 + tmp237;
tmp265 = tmp251 + tmp252;
tmp266 = tmp264 - tmp265;
tmp270 = tmp264 + tmp265;
}
{
fftw_real tmp259;
fftw_real tmp263;
fftw_real tmp267;
fftw_real tmp269;
ASSERT_ALIGNED_DOUBLE;
tmp259 = c_re(W[6]);
tmp263 = c_im(W[6]);
Y[-8 * iostride] = (tmp259 * tmp262) - (tmp263 * tmp266);
X[7 * iostride] = (tmp263 * tmp262) + (tmp259 * tmp266);
tmp267 = c_re(W[14]);
tmp269 = c_im(W[14]);
Y[0] = (tmp267 * tmp268) - (tmp269 * tmp270);
X[15 * iostride] = (tmp269 * tmp268) + (tmp267 * tmp270);
}
}
}
if (i == m) {
fftw_real tmp7;
fftw_real tmp51;
fftw_real tmp19;
fftw_real tmp43;
fftw_real tmp39;
fftw_real tmp47;
fftw_real tmp59;
fftw_real tmp64;
fftw_real tmp14;
fftw_real tmp56;
fftw_real tmp24;
fftw_real tmp32;
fftw_real tmp29;
fftw_real tmp33;
fftw_real tmp54;
fftw_real tmp65;
fftw_real tmp63;
fftw_real tmp66;
ASSERT_ALIGNED_DOUBLE;
{
fftw_real tmp3;
fftw_real tmp15;
fftw_real tmp38;
fftw_real tmp57;
fftw_real tmp6;
fftw_real tmp35;
fftw_real tmp18;
fftw_real tmp58;
ASSERT_ALIGNED_DOUBLE;
{
fftw_real tmp1;
fftw_real tmp2;
fftw_real tmp36;
fftw_real tmp37;
ASSERT_ALIGNED_DOUBLE;
tmp1 = X[0];
tmp2 = X[7 * iostride];
tmp3 = tmp1 + tmp2;
tmp15 = tmp1 - tmp2;
tmp36 = Y[0];
tmp37 = Y[-7 * iostride];
tmp38 = tmp36 + tmp37;
tmp57 = tmp36 - tmp37;
}
{
fftw_real tmp4;
fftw_real tmp5;
fftw_real tmp16;
fftw_real tmp17;
ASSERT_ALIGNED_DOUBLE;
tmp4 = X[4 * iostride];
tmp5 = X[3 * iostride];
tmp6 = tmp4 + tmp5;
tmp35 = tmp4 - tmp5;
tmp16 = Y[-4 * iostride];
tmp17 = Y[-3 * iostride];
tmp18 = tmp16 + tmp17;
tmp58 = tmp16 - tmp17;
}
tmp7 = tmp3 + tmp6;
tmp51 = tmp3 - tmp6;
tmp19 = tmp15 - tmp18;
tmp43 = tmp15 + tmp18;
tmp39 = tmp35 + tmp38;
tmp47 = tmp38 - tmp35;
tmp59 = tmp57 - tmp58;
tmp64 = tmp58 + tmp57;
}
{
fftw_real tmp10;
fftw_real tmp20;
fftw_real tmp23;
fftw_real tmp53;
fftw_real tmp13;
fftw_real tmp25;
fftw_real tmp28;
fftw_real tmp52;
ASSERT_ALIGNED_DOUBLE;
{
fftw_real tmp8;
fftw_real tmp9;
fftw_real tmp21;
fftw_real tmp22;
ASSERT_ALIGNED_DOUBLE;
tmp8 = X[2 * iostride];
tmp9 = X[5 * iostride];
tmp10 = tmp8 + tmp9;
tmp20 = tmp8 - tmp9;
tmp21 = Y[-2 * iostride];
tmp22 = Y[-5 * iostride];
tmp23 = tmp21 + tmp22;
tmp53 = tmp21 - tmp22;
}
{
fftw_real tmp11;
fftw_real tmp12;
fftw_real tmp26;
fftw_real tmp27;
ASSERT_ALIGNED_DOUBLE;
tmp11 = X[iostride];
tmp12 = X[6 * iostride];
tmp13 = tmp11 + tmp12;
tmp25 = tmp11 - tmp12;
tmp26 = Y[-iostride];
tmp27 = Y[-6 * iostride];
tmp28 = tmp26 + tmp27;
tmp52 = tmp27 - tmp26;
}
tmp14 = tmp10 + tmp13;
tmp56 = tmp10 - tmp13;
tmp24 = tmp20 - tmp23;
tmp32 = tmp20 + tmp23;
tmp29 = tmp25 - tmp28;
tmp33 = tmp25 + tmp28;
tmp54 = tmp52 - tmp53;
tmp65 = tmp53 + tmp52;
}
X[0] = K2_000000000 * (tmp7 + tmp14);
X[8 * iostride] = -(K2_000000000 * (tmp65 + tmp64));
tmp63 = tmp7 - tmp14;
tmp66 = tmp64 - tmp65;
X[4 * iostride] = K1_414213562 * (tmp63 - tmp66);
X[12 * iostride] = -(K1_414213562 * (tmp63 + tmp66));
{
fftw_real tmp61;
fftw_real tmp62;
fftw_real tmp55;
fftw_real tmp60;
ASSERT_ALIGNED_DOUBLE;
tmp61 = tmp51 - tmp54;
tmp62 = tmp59 - tmp56;
X[6 * iostride] = (K765366864 * tmp61) - (K1_847759065 * tmp62);
X[14 * iostride] = -((K1_847759065 * tmp61) + (K765366864 * tmp62));
tmp55 = tmp51 + tmp54;
tmp60 = tmp56 + tmp59;
X[2 * iostride] = (K1_847759065 * tmp55) - (K765366864 * tmp60);
X[10 * iostride] = -((K765366864 * tmp55) + (K1_847759065 * tmp60));
}
{
fftw_real tmp45;
fftw_real tmp49;
fftw_real tmp48;
fftw_real tmp50;
fftw_real tmp44;
fftw_real tmp46;
ASSERT_ALIGNED_DOUBLE;
tmp44 = K707106781 * (tmp32 + tmp33);
tmp45 = tmp43 - tmp44;
tmp49 = tmp43 + tmp44;
tmp46 = K707106781 * (tmp24 - tmp29);
tmp48 = tmp46 + tmp47;
tmp50 = tmp47 - tmp46;
X[3 * iostride] = (K1_662939224 * tmp45) - (K1_111140466 * tmp48);
X[11 * iostride] = -((K1_111140466 * tmp45) + (K1_662939224 * tmp48));
X[7 * iostride] = (K390180644 * tmp49) - (K1_961570560 * tmp50);
X[15 * iostride] = -((K1_961570560 * tmp49) + (K390180644 * tmp50));
}
{
fftw_real tmp31;
fftw_real tmp41;
fftw_real tmp40;
fftw_real tmp42;
fftw_real tmp30;
fftw_real tmp34;
ASSERT_ALIGNED_DOUBLE;
tmp30 = K707106781 * (tmp24 + tmp29);
tmp31 = tmp19 + tmp30;
tmp41 = tmp19 - tmp30;
tmp34 = K707106781 * (tmp32 - tmp33);
tmp40 = tmp34 + tmp39;
tmp42 = tmp39 - tmp34;
X[iostride] = (K1_961570560 * tmp31) - (K390180644 * tmp40);
X[9 * iostride] = -((K390180644 * tmp31) + (K1_961570560 * tmp40));
X[5 * iostride] = (K1_111140466 * tmp41) - (K1_662939224 * tmp42);
X[13 * iostride] = -((K1_662939224 * tmp41) + (K1_111140466 * tmp42));
}
}
}
void fftwi_twiddle_6(fftw_complex *A, const fftw_complex *W, int iostride,
int m, int dist)
{
int i;
fftw_complex *inout;
inout = A;
for (i = m; i > 0; i = i - 1, inout = inout + dist, W = W + 5) {
fftw_real tmp7;
fftw_real tmp31;
fftw_real tmp50;
fftw_real tmp54;
fftw_real tmp29;
fftw_real tmp33;
fftw_real tmp38;
fftw_real tmp44;
fftw_real tmp18;
fftw_real tmp32;
fftw_real tmp41;
fftw_real tmp45;
ASSERT_ALIGNED_DOUBLE;
{
fftw_real tmp1;
fftw_real tmp49;
fftw_real tmp6;
fftw_real tmp48;
ASSERT_ALIGNED_DOUBLE;
tmp1 = c_re(inout[0]);
tmp49 = c_im(inout[0]);
{
fftw_real tmp3;
fftw_real tmp5;
fftw_real tmp2;
fftw_real tmp4;
ASSERT_ALIGNED_DOUBLE;
tmp3 = c_re(inout[3 * iostride]);
tmp5 = c_im(inout[3 * iostride]);
tmp2 = c_re(W[2]);
tmp4 = c_im(W[2]);
tmp6 = (tmp2 * tmp3) + (tmp4 * tmp5);
tmp48 = (tmp2 * tmp5) - (tmp4 * tmp3);
}
tmp7 = tmp1 - tmp6;
tmp31 = tmp1 + tmp6;
tmp50 = tmp48 + tmp49;
tmp54 = tmp49 - tmp48;
}
{
fftw_real tmp23;
fftw_real tmp36;
fftw_real tmp28;
fftw_real tmp37;
ASSERT_ALIGNED_DOUBLE;
{
fftw_real tmp20;
fftw_real tmp22;
fftw_real tmp19;
fftw_real tmp21;
ASSERT_ALIGNED_DOUBLE;
tmp20 = c_re(inout[4 * iostride]);
tmp22 = c_im(inout[4 * iostride]);
tmp19 = c_re(W[3]);
tmp21 = c_im(W[3]);
tmp23 = (tmp19 * tmp20) + (tmp21 * tmp22);
tmp36 = (tmp19 * tmp22) - (tmp21 * tmp20);
}
{
fftw_real tmp25;
fftw_real tmp27;
fftw_real tmp24;
fftw_real tmp26;
ASSERT_ALIGNED_DOUBLE;
tmp25 = c_re(inout[iostride]);
tmp27 = c_im(inout[iostride]);
tmp24 = c_re(W[0]);
tmp26 = c_im(W[0]);
tmp28 = (tmp24 * tmp25) + (tmp26 * tmp27);
tmp37 = (tmp24 * tmp27) - (tmp26 * tmp25);
}
tmp29 = tmp23 - tmp28;
tmp33 = tmp23 + tmp28;
tmp38 = tmp36 - tmp37;
tmp44 = tmp36 + tmp37;
}
{
fftw_real tmp12;
fftw_real tmp39;
fftw_real tmp17;
fftw_real tmp40;
ASSERT_ALIGNED_DOUBLE;
{
fftw_real tmp9;
fftw_real tmp11;
fftw_real tmp8;
fftw_real tmp10;
ASSERT_ALIGNED_DOUBLE;
tmp9 = c_re(inout[2 * iostride]);
tmp11 = c_im(inout[2 * iostride]);
tmp8 = c_re(W[1]);
tmp10 = c_im(W[1]);
tmp12 = (tmp8 * tmp9) + (tmp10 * tmp11);
tmp39 = (tmp8 * tmp11) - (tmp10 * tmp9);
}
{
fftw_real tmp14;
fftw_real tmp16;
fftw_real tmp13;
fftw_real tmp15;
ASSERT_ALIGNED_DOUBLE;
tmp14 = c_re(inout[5 * iostride]);
tmp16 = c_im(inout[5 * iostride]);
tmp13 = c_re(W[4]);
tmp15 = c_im(W[4]);
tmp17 = (tmp13 * tmp14) + (tmp15 * tmp16);
tmp40 = (tmp13 * tmp16) - (tmp15 * tmp14);
}
tmp18 = tmp12 - tmp17;
tmp32 = tmp12 + tmp17;
tmp41 = tmp39 - tmp40;
tmp45 = tmp39 + tmp40;
}
{
fftw_real tmp42;
fftw_real tmp30;
fftw_real tmp35;
fftw_real tmp53;
fftw_real tmp55;
fftw_real tmp56;
ASSERT_ALIGNED_DOUBLE;
tmp42 = K866025403 * (tmp38 - tmp41);
tmp30 = tmp18 + tmp29;
tmp35 = tmp7 - (K500000000 * tmp30);
c_re(inout[3 * iostride]) = tmp7 + tmp30;
c_re(inout[iostride]) = tmp35 + tmp42;
c_re(inout[5 * iostride]) = tmp35 - tmp42;
tmp53 = K866025403 * (tmp18 - tmp29);
tmp55 = tmp41 + tmp38;
tmp56 = tmp54 - (K500000000 * tmp55);
c_im(inout[iostride]) = tmp53 + tmp56;
c_im(inout[5 * iostride]) = tmp56 - tmp53;
c_im(inout[3 * iostride]) = tmp55 + tmp54;
}
{
fftw_real tmp46;
fftw_real tmp34;
fftw_real tmp43;
fftw_real tmp52;
fftw_real tmp47;
fftw_real tmp51;
ASSERT_ALIGNED_DOUBLE;
tmp46 = K866025403 * (tmp44 - tmp45);
tmp34 = tmp32 + tmp33;
tmp43 = tmp31 - (K500000000 * tmp34);
c_re(inout[0]) = tmp31 + tmp34;
c_re(inout[4 * iostride]) = tmp43 + tmp46;
c_re(inout[2 * iostride]) = tmp43 - tmp46;
tmp52 = K866025403 * (tmp32 - tmp33);
tmp47 = tmp45 + tmp44;
tmp51 = tmp50 - (K500000000 * tmp47);
c_im(inout[0]) = tmp47 + tmp50;
c_im(inout[4 * iostride]) = tmp52 + tmp51;
c_im(inout[2 * iostride]) = tmp51 - tmp52;
}
}
}
void fftw_no_twiddle_13(const fftw_complex *input, fftw_complex *output, int istride, int ostride)
{
fftw_real tmp1;
fftw_real tmp88;
fftw_real tmp29;
fftw_real tmp36;
fftw_real tmp43;
fftw_real tmp121;
fftw_real tmp128;
fftw_real tmp30;
fftw_real tmp24;
fftw_real tmp131;
fftw_real tmp124;
fftw_real tmp129;
fftw_real tmp41;
fftw_real tmp44;
fftw_real tmp134;
fftw_real tmp83;
fftw_real tmp89;
fftw_real tmp70;
fftw_real tmp85;
fftw_real tmp137;
fftw_real tmp141;
fftw_real tmp146;
fftw_real tmp77;
fftw_real tmp86;
fftw_real tmp144;
fftw_real tmp147;
ASSERT_ALIGNED_DOUBLE;
tmp1 = c_re(input[0]);
tmp88 = c_im(input[0]);
{
fftw_real tmp15;
fftw_real tmp25;
fftw_real tmp18;
fftw_real tmp26;
fftw_real tmp21;
fftw_real tmp27;
fftw_real tmp22;
fftw_real tmp28;
fftw_real tmp6;
fftw_real tmp37;
fftw_real tmp33;
fftw_real tmp11;
fftw_real tmp38;
fftw_real tmp34;
fftw_real tmp13;
fftw_real tmp14;
fftw_real tmp12;
fftw_real tmp23;
ASSERT_ALIGNED_DOUBLE;
tmp13 = c_re(input[8 * istride]);
tmp14 = c_re(input[5 * istride]);
tmp15 = tmp13 + tmp14;
tmp25 = tmp13 - tmp14;
{
fftw_real tmp16;
fftw_real tmp17;
fftw_real tmp19;
fftw_real tmp20;
ASSERT_ALIGNED_DOUBLE;
tmp16 = c_re(input[6 * istride]);
tmp17 = c_re(input[11 * istride]);
tmp18 = tmp16 + tmp17;
tmp26 = tmp16 - tmp17;
tmp19 = c_re(input[2 * istride]);
tmp20 = c_re(input[7 * istride]);
tmp21 = tmp19 + tmp20;
tmp27 = tmp19 - tmp20;
}
tmp22 = tmp18 + tmp21;
tmp28 = tmp26 + tmp27;
{
fftw_real tmp2;
fftw_real tmp3;
fftw_real tmp4;
fftw_real tmp5;
ASSERT_ALIGNED_DOUBLE;
tmp2 = c_re(input[istride]);
tmp3 = c_re(input[3 * istride]);
tmp4 = c_re(input[9 * istride]);
tmp5 = tmp3 + tmp4;
tmp6 = tmp2 + tmp5;
tmp37 = tmp2 - (K500000000 * tmp5);
tmp33 = tmp3 - tmp4;
}
{
fftw_real tmp7;
fftw_real tmp8;
fftw_real tmp9;
fftw_real tmp10;
ASSERT_ALIGNED_DOUBLE;
tmp7 = c_re(input[12 * istride]);
tmp8 = c_re(input[4 * istride]);
tmp9 = c_re(input[10 * istride]);
tmp10 = tmp8 + tmp9;
tmp11 = tmp7 + tmp10;
tmp38 = tmp7 - (K500000000 * tmp10);
tmp34 = tmp8 - tmp9;
}
tmp29 = tmp25 - tmp28;
{
fftw_real tmp32;
fftw_real tmp35;
fftw_real tmp119;
fftw_real tmp120;
ASSERT_ALIGNED_DOUBLE;
tmp32 = tmp25 + (K500000000 * tmp28);
tmp35 = K866025403 * (tmp33 + tmp34);
tmp36 = tmp32 - tmp35;
tmp43 = tmp35 + tmp32;
tmp119 = tmp33 - tmp34;
tmp120 = tmp27 - tmp26;
tmp121 = tmp119 + tmp120;
tmp128 = tmp120 - tmp119;
}
tmp30 = tmp6 - tmp11;
tmp12 = tmp6 + tmp11;
tmp23 = tmp15 + tmp22;
tmp24 = tmp12 + tmp23;
tmp131 = K300462606 * (tmp12 - tmp23);
{
fftw_real tmp122;
fftw_real tmp123;
fftw_real tmp39;
fftw_real tmp40;
ASSERT_ALIGNED_DOUBLE;
tmp122 = tmp37 + tmp38;
tmp123 = tmp15 - (K500000000 * tmp22);
tmp124 = tmp122 + tmp123;
tmp129 = tmp122 - tmp123;
tmp39 = tmp37 - tmp38;
tmp40 = K866025403 * (tmp18 - tmp21);
tmp41 = tmp39 + tmp40;
tmp44 = tmp39 - tmp40;
}
}
{
fftw_real tmp61;
fftw_real tmp135;
fftw_real tmp64;
fftw_real tmp71;
fftw_real tmp67;
fftw_real tmp72;
fftw_real tmp68;
fftw_real tmp136;
fftw_real tmp52;
fftw_real tmp79;
fftw_real tmp75;
fftw_real tmp57;
fftw_real tmp80;
fftw_real tmp74;
fftw_real tmp59;
fftw_real tmp60;
fftw_real tmp139;
fftw_real tmp140;
ASSERT_ALIGNED_DOUBLE;
tmp59 = c_im(input[8 * istride]);
tmp60 = c_im(input[5 * istride]);
tmp61 = tmp59 + tmp60;
tmp135 = tmp59 - tmp60;
{
fftw_real tmp62;
fftw_real tmp63;
fftw_real tmp65;
fftw_real tmp66;
ASSERT_ALIGNED_DOUBLE;
tmp62 = c_im(input[6 * istride]);
tmp63 = c_im(input[11 * istride]);
tmp64 = tmp62 + tmp63;
tmp71 = tmp62 - tmp63;
tmp65 = c_im(input[2 * istride]);
tmp66 = c_im(input[7 * istride]);
tmp67 = tmp65 + tmp66;
tmp72 = tmp65 - tmp66;
}
tmp68 = tmp64 + tmp67;
tmp136 = tmp71 + tmp72;
{
fftw_real tmp48;
fftw_real tmp49;
fftw_real tmp50;
fftw_real tmp51;
ASSERT_ALIGNED_DOUBLE;
tmp48 = c_im(input[istride]);
tmp49 = c_im(input[3 * istride]);
tmp50 = c_im(input[9 * istride]);
tmp51 = tmp49 + tmp50;
tmp52 = tmp48 - (K500000000 * tmp51);
tmp79 = tmp48 + tmp51;
tmp75 = tmp49 - tmp50;
}
{
fftw_real tmp53;
fftw_real tmp54;
fftw_real tmp55;
fftw_real tmp56;
ASSERT_ALIGNED_DOUBLE;
tmp53 = c_im(input[12 * istride]);
tmp54 = c_im(input[4 * istride]);
tmp55 = c_im(input[10 * istride]);
tmp56 = tmp54 + tmp55;
tmp57 = tmp53 - (K500000000 * tmp56);
tmp80 = tmp53 + tmp56;
tmp74 = tmp54 - tmp55;
}
tmp134 = tmp79 - tmp80;
{
fftw_real tmp81;
fftw_real tmp82;
fftw_real tmp58;
fftw_real tmp69;
ASSERT_ALIGNED_DOUBLE;
tmp81 = tmp79 + tmp80;
tmp82 = tmp61 + tmp68;
tmp83 = K300462606 * (tmp81 - tmp82);
tmp89 = tmp81 + tmp82;
tmp58 = tmp52 + tmp57;
tmp69 = tmp61 - (K500000000 * tmp68);
tmp70 = tmp58 - tmp69;
tmp85 = tmp58 + tmp69;
}
tmp137 = tmp135 - tmp136;
tmp139 = K866025403 * (tmp75 + tmp74);
tmp140 = tmp135 + (K500000000 * tmp136);
tmp141 = tmp139 - tmp140;
tmp146 = tmp139 + tmp140;
{
fftw_real tmp73;
fftw_real tmp76;
fftw_real tmp142;
fftw_real tmp143;
ASSERT_ALIGNED_DOUBLE;
tmp73 = tmp71 - tmp72;
tmp76 = tmp74 - tmp75;
tmp77 = tmp73 - tmp76;
tmp86 = tmp76 + tmp73;
tmp142 = tmp52 - tmp57;
tmp143 = K866025403 * (tmp67 - tmp64);
tmp144 = tmp142 - tmp143;
tmp147 = tmp142 + tmp143;
}
}
c_re(output[0]) = tmp1 + tmp24;
{
fftw_real tmp163;
fftw_real tmp173;
fftw_real tmp127;
fftw_real tmp169;
fftw_real tmp153;
fftw_real tmp132;
fftw_real tmp138;
fftw_real tmp149;
fftw_real tmp160;
fftw_real tmp172;
fftw_real tmp154;
fftw_real tmp157;
fftw_real tmp158;
fftw_real tmp170;
fftw_real tmp161;
fftw_real tmp162;
ASSERT_ALIGNED_DOUBLE;
tmp161 = (K113854479 * tmp121) - (K503537032 * tmp124);
tmp162 = (K387390585 * tmp128) - (K265966249 * tmp129);
tmp163 = tmp161 - tmp162;
tmp173 = tmp162 + tmp161;
{
fftw_real tmp130;
fftw_real tmp151;
fftw_real tmp125;
fftw_real tmp126;
fftw_real tmp152;
ASSERT_ALIGNED_DOUBLE;
tmp130 = (K132983124 * tmp128) + (K258260390 * tmp129);
tmp151 = tmp131 - tmp130;
tmp125 = (K251768516 * tmp121) + (K075902986 * tmp124);
tmp126 = tmp1 - (K083333333 * tmp24);
tmp152 = tmp126 - tmp125;
tmp127 = (K2_000000000 * tmp125) + tmp126;
tmp169 = tmp152 - tmp151;
tmp153 = tmp151 + tmp152;
tmp132 = (K2_000000000 * tmp130) + tmp131;
}
{
fftw_real tmp145;
fftw_real tmp148;
fftw_real tmp155;
fftw_real tmp156;
ASSERT_ALIGNED_DOUBLE;
tmp138 = (K575140729 * tmp134) + (K174138601 * tmp137);
tmp145 = (K011599105 * tmp141) + (K300238635 * tmp144);
tmp148 = (K156891391 * tmp146) - (K256247671 * tmp147);
tmp149 = tmp145 + tmp148;
tmp160 = K1_732050807 * (tmp148 - tmp145);
tmp172 = tmp149 - tmp138;
tmp154 = (K174138601 * tmp134) - (K575140729 * tmp137);
tmp155 = (K300238635 * tmp141) - (K011599105 * tmp144);
tmp156 = (K256247671 * tmp146) + (K156891391 * tmp147);
tmp157 = tmp155 + tmp156;
tmp158 = tmp154 - tmp157;
tmp170 = K1_732050807 * (tmp156 - tmp155);
}
{
fftw_real tmp133;
fftw_real tmp150;
fftw_real tmp165;
fftw_real tmp166;
ASSERT_ALIGNED_DOUBLE;
tmp133 = tmp127 - tmp132;
tmp150 = tmp138 + (K2_000000000 * tmp149);
c_re(output[8 * ostride]) = tmp133 - tmp150;
c_re(output[5 * ostride]) = tmp133 + tmp150;
{
fftw_real tmp167;
fftw_real tmp168;
fftw_real tmp159;
fftw_real tmp164;
ASSERT_ALIGNED_DOUBLE;
tmp167 = tmp132 + tmp127;
tmp168 = tmp154 + (K2_000000000 * tmp157);
c_re(output[12 * ostride]) = tmp167 - tmp168;
c_re(output[ostride]) = tmp167 + tmp168;
tmp159 = tmp153 - tmp158;
tmp164 = tmp160 - tmp163;
c_re(output[4 * ostride]) = tmp159 - tmp164;
c_re(output[10 * ostride]) = tmp164 + tmp159;
}
tmp165 = tmp153 + tmp158;
tmp166 = tmp163 + tmp160;
c_re(output[3 * ostride]) = tmp165 - tmp166;
c_re(output[9 * ostride]) = tmp166 + tmp165;
{
fftw_real tmp175;
fftw_real tmp176;
fftw_real tmp171;
fftw_real tmp174;
ASSERT_ALIGNED_DOUBLE;
tmp175 = tmp169 + tmp170;
tmp176 = tmp173 + tmp172;
c_re(output[2 * ostride]) = tmp175 - tmp176;
c_re(output[7 * ostride]) = tmp176 + tmp175;
tmp171 = tmp169 - tmp170;
tmp174 = tmp172 - tmp173;
c_re(output[6 * ostride]) = tmp171 - tmp174;
c_re(output[11 * ostride]) = tmp174 + tmp171;
}
}
}
c_im(output[0]) = tmp88 + tmp89;
{
fftw_real tmp102;
fftw_real tmp115;
fftw_real tmp84;
fftw_real tmp112;
fftw_real tmp106;
fftw_real tmp91;
fftw_real tmp31;
fftw_real tmp46;
fftw_real tmp107;
fftw_real tmp111;
fftw_real tmp94;
fftw_real tmp97;
fftw_real tmp99;
fftw_real tmp114;
fftw_real tmp100;
fftw_real tmp101;
ASSERT_ALIGNED_DOUBLE;
tmp100 = (K387390585 * tmp77) + (K265966249 * tmp70);
tmp101 = (K113854479 * tmp86) + (K503537032 * tmp85);
tmp102 = tmp100 + tmp101;
tmp115 = tmp100 - tmp101;
{
fftw_real tmp78;
fftw_real tmp105;
fftw_real tmp87;
fftw_real tmp90;
fftw_real tmp104;
ASSERT_ALIGNED_DOUBLE;
tmp78 = (K258260390 * tmp70) - (K132983124 * tmp77);
tmp105 = tmp83 - tmp78;
tmp87 = (K075902986 * tmp85) - (K251768516 * tmp86);
tmp90 = tmp88 - (K083333333 * tmp89);
tmp104 = tmp90 - tmp87;
tmp84 = (K2_000000000 * tmp78) + tmp83;
tmp112 = tmp105 + tmp104;
tmp106 = tmp104 - tmp105;
tmp91 = (K2_000000000 * tmp87) + tmp90;
}
{
fftw_real tmp42;
fftw_real tmp45;
fftw_real tmp95;
fftw_real tmp96;
ASSERT_ALIGNED_DOUBLE;
tmp31 = (K575140729 * tmp29) - (K174138601 * tmp30);
tmp42 = (K300238635 * tmp36) + (K011599105 * tmp41);
tmp45 = (K256247671 * tmp43) + (K156891391 * tmp44);
tmp46 = tmp42 - tmp45;
tmp107 = K1_732050807 * (tmp45 + tmp42);
tmp111 = tmp31 - tmp46;
tmp94 = (K575140729 * tmp30) + (K174138601 * tmp29);
tmp95 = (K156891391 * tmp43) - (K256247671 * tmp44);
tmp96 = (K300238635 * tmp41) - (K011599105 * tmp36);
tmp97 = tmp95 + tmp96;
tmp99 = tmp97 - tmp94;
tmp114 = K1_732050807 * (tmp96 - tmp95);
}
{
fftw_real tmp47;
fftw_real tmp92;
fftw_real tmp109;
fftw_real tmp110;
ASSERT_ALIGNED_DOUBLE;
tmp47 = tmp31 + (K2_000000000 * tmp46);
tmp92 = tmp84 + tmp91;
c_im(output[ostride]) = tmp47 + tmp92;
c_im(output[12 * ostride]) = tmp92 - tmp47;
{
fftw_real tmp93;
fftw_real tmp98;
fftw_real tmp103;
fftw_real tmp108;
ASSERT_ALIGNED_DOUBLE;
tmp93 = tmp91 - tmp84;
tmp98 = tmp94 + (K2_000000000 * tmp97);
c_im(output[5 * ostride]) = tmp93 - tmp98;
c_im(output[8 * ostride]) = tmp98 + tmp93;
tmp103 = tmp99 + tmp102;
tmp108 = tmp106 - tmp107;
c_im(output[2 * ostride]) = tmp103 + tmp108;
c_im(output[7 * ostride]) = tmp108 - tmp103;
}
tmp109 = tmp107 + tmp106;
tmp110 = tmp102 - tmp99;
c_im(output[6 * ostride]) = tmp109 - tmp110;
c_im(output[11 * ostride]) = tmp110 + tmp109;
{
fftw_real tmp117;
fftw_real tmp118;
fftw_real tmp113;
fftw_real tmp116;
ASSERT_ALIGNED_DOUBLE;
tmp117 = tmp112 - tmp111;
tmp118 = tmp114 - tmp115;
c_im(output[4 * ostride]) = tmp117 - tmp118;
c_im(output[10 * ostride]) = tmp118 + tmp117;
tmp113 = tmp111 + tmp112;
tmp116 = tmp114 + tmp115;
c_im(output[3 * ostride]) = tmp113 - tmp116;
c_im(output[9 * ostride]) = tmp116 + tmp113;
}
}
}
}
static void mkoddonly(C *a, int n)
{
int i;
for (i = 0; i < n; i += 2)
c_re(a[i]) = c_im(a[i]) = 0.0;
}
void fftwi_no_twiddle_14(const FFTW_COMPLEX *in, FFTW_COMPLEX *out, int istride, int ostride)
{
FFTW_REAL tre0_0_0;
FFTW_REAL tim0_0_0;
FFTW_REAL tre0_0_1;
FFTW_REAL tim0_0_1;
FFTW_REAL tre0_0_2;
FFTW_REAL tim0_0_2;
FFTW_REAL tre0_0_3;
FFTW_REAL tim0_0_3;
FFTW_REAL tre0_0_4;
FFTW_REAL tim0_0_4;
FFTW_REAL tre0_0_5;
FFTW_REAL tim0_0_5;
FFTW_REAL tre0_0_6;
FFTW_REAL tim0_0_6;
FFTW_REAL tre0_1_0;
FFTW_REAL tim0_1_0;
FFTW_REAL tre0_1_1;
FFTW_REAL tim0_1_1;
FFTW_REAL tre0_1_2;
FFTW_REAL tim0_1_2;
FFTW_REAL tre0_1_3;
FFTW_REAL tim0_1_3;
FFTW_REAL tre0_1_4;
FFTW_REAL tim0_1_4;
FFTW_REAL tre0_1_5;
FFTW_REAL tim0_1_5;
FFTW_REAL tre0_1_6;
FFTW_REAL tim0_1_6;
{
FFTW_REAL tre1_0_0;
FFTW_REAL tim1_0_0;
FFTW_REAL tre1_1_0;
FFTW_REAL tim1_1_0;
tre1_0_0 = c_re(in[0]);
tim1_0_0 = c_im(in[0]);
tre1_1_0 = c_re(in[7 * istride]);
tim1_1_0 = c_im(in[7 * istride]);
tre0_0_0 = tre1_0_0 + tre1_1_0;
tim0_0_0 = tim1_0_0 + tim1_1_0;
tre0_1_0 = tre1_0_0 - tre1_1_0;
tim0_1_0 = tim1_0_0 - tim1_1_0;
}
{
FFTW_REAL tre1_0_0;
FFTW_REAL tim1_0_0;
FFTW_REAL tre1_1_0;
FFTW_REAL tim1_1_0;
tre1_0_0 = c_re(in[2 * istride]);
tim1_0_0 = c_im(in[2 * istride]);
tre1_1_0 = c_re(in[9 * istride]);
tim1_1_0 = c_im(in[9 * istride]);
tre0_0_1 = tre1_0_0 + tre1_1_0;
tim0_0_1 = tim1_0_0 + tim1_1_0;
tre0_1_1 = tre1_0_0 - tre1_1_0;
tim0_1_1 = tim1_0_0 - tim1_1_0;
}
{
FFTW_REAL tre1_0_0;
FFTW_REAL tim1_0_0;
FFTW_REAL tre1_1_0;
FFTW_REAL tim1_1_0;
tre1_0_0 = c_re(in[4 * istride]);
tim1_0_0 = c_im(in[4 * istride]);
tre1_1_0 = c_re(in[11 * istride]);
tim1_1_0 = c_im(in[11 * istride]);
tre0_0_2 = tre1_0_0 + tre1_1_0;
tim0_0_2 = tim1_0_0 + tim1_1_0;
tre0_1_2 = tre1_0_0 - tre1_1_0;
tim0_1_2 = tim1_0_0 - tim1_1_0;
}
{
FFTW_REAL tre1_0_0;
FFTW_REAL tim1_0_0;
FFTW_REAL tre1_1_0;
FFTW_REAL tim1_1_0;
tre1_0_0 = c_re(in[6 * istride]);
tim1_0_0 = c_im(in[6 * istride]);
tre1_1_0 = c_re(in[13 * istride]);
tim1_1_0 = c_im(in[13 * istride]);
tre0_0_3 = tre1_0_0 + tre1_1_0;
tim0_0_3 = tim1_0_0 + tim1_1_0;
tre0_1_3 = tre1_0_0 - tre1_1_0;
tim0_1_3 = tim1_0_0 - tim1_1_0;
}
{
FFTW_REAL tre1_0_0;
FFTW_REAL tim1_0_0;
FFTW_REAL tre1_1_0;
FFTW_REAL tim1_1_0;
tre1_0_0 = c_re(in[8 * istride]);
tim1_0_0 = c_im(in[8 * istride]);
tre1_1_0 = c_re(in[istride]);
tim1_1_0 = c_im(in[istride]);
tre0_0_4 = tre1_0_0 + tre1_1_0;
tim0_0_4 = tim1_0_0 + tim1_1_0;
tre0_1_4 = tre1_0_0 - tre1_1_0;
tim0_1_4 = tim1_0_0 - tim1_1_0;
}
{
FFTW_REAL tre1_0_0;
FFTW_REAL tim1_0_0;
FFTW_REAL tre1_1_0;
FFTW_REAL tim1_1_0;
tre1_0_0 = c_re(in[10 * istride]);
tim1_0_0 = c_im(in[10 * istride]);
tre1_1_0 = c_re(in[3 * istride]);
tim1_1_0 = c_im(in[3 * istride]);
tre0_0_5 = tre1_0_0 + tre1_1_0;
tim0_0_5 = tim1_0_0 + tim1_1_0;
tre0_1_5 = tre1_0_0 - tre1_1_0;
tim0_1_5 = tim1_0_0 - tim1_1_0;
}
{
FFTW_REAL tre1_0_0;
FFTW_REAL tim1_0_0;
FFTW_REAL tre1_1_0;
FFTW_REAL tim1_1_0;
tre1_0_0 = c_re(in[12 * istride]);
tim1_0_0 = c_im(in[12 * istride]);
tre1_1_0 = c_re(in[5 * istride]);
tim1_1_0 = c_im(in[5 * istride]);
tre0_0_6 = tre1_0_0 + tre1_1_0;
tim0_0_6 = tim1_0_0 + tim1_1_0;
tre0_1_6 = tre1_0_0 - tre1_1_0;
tim0_1_6 = tim1_0_0 - tim1_1_0;
}
c_re(out[0]) = tre0_0_0 + tre0_0_1 + tre0_0_2 + tre0_0_3 + tre0_0_4 + tre0_0_5 + tre0_0_6;
c_im(out[0]) = tim0_0_0 + tim0_0_1 + tim0_0_2 + tim0_0_3 + tim0_0_4 + tim0_0_5 + tim0_0_6;
{
FFTW_REAL tre2_0_0;
FFTW_REAL tre2_1_0;
tre2_0_0 = tre0_0_0 + (((FFTW_REAL) FFTW_K623489801) * (tre0_0_1 + tre0_0_6)) - (((FFTW_REAL) FFTW_K900968867) * (tre0_0_3 + tre0_0_4)) - (((FFTW_REAL) FFTW_K222520933) * (tre0_0_2 + tre0_0_5));
tre2_1_0 = (((FFTW_REAL) FFTW_K781831482) * (tim0_0_6 - tim0_0_1)) + (((FFTW_REAL) FFTW_K974927912) * (tim0_0_5 - tim0_0_2)) + (((FFTW_REAL) FFTW_K433883739) * (tim0_0_4 - tim0_0_3));
c_re(out[8 * ostride]) = tre2_0_0 + tre2_1_0;
c_re(out[6 * ostride]) = tre2_0_0 - tre2_1_0;
}
{
FFTW_REAL tim2_0_0;
FFTW_REAL tim2_1_0;
tim2_0_0 = tim0_0_0 + (((FFTW_REAL) FFTW_K623489801) * (tim0_0_1 + tim0_0_6)) - (((FFTW_REAL) FFTW_K900968867) * (tim0_0_3 + tim0_0_4)) - (((FFTW_REAL) FFTW_K222520933) * (tim0_0_2 + tim0_0_5));
tim2_1_0 = (((FFTW_REAL) FFTW_K781831482) * (tre0_0_1 - tre0_0_6)) + (((FFTW_REAL) FFTW_K974927912) * (tre0_0_2 - tre0_0_5)) + (((FFTW_REAL) FFTW_K433883739) * (tre0_0_3 - tre0_0_4));
c_im(out[8 * ostride]) = tim2_0_0 + tim2_1_0;
c_im(out[6 * ostride]) = tim2_0_0 - tim2_1_0;
}
{
FFTW_REAL tre2_0_0;
FFTW_REAL tre2_1_0;
tre2_0_0 = tre0_0_0 + (((FFTW_REAL) FFTW_K623489801) * (tre0_0_3 + tre0_0_4)) - (((FFTW_REAL) FFTW_K900968867) * (tre0_0_2 + tre0_0_5)) - (((FFTW_REAL) FFTW_K222520933) * (tre0_0_1 + tre0_0_6));
tre2_1_0 = (((FFTW_REAL) FFTW_K974927912) * (tim0_0_6 - tim0_0_1)) + (((FFTW_REAL) FFTW_K433883739) * (tim0_0_2 - tim0_0_5)) + (((FFTW_REAL) FFTW_K781831482) * (tim0_0_3 - tim0_0_4));
c_re(out[2 * ostride]) = tre2_0_0 + tre2_1_0;
c_re(out[12 * ostride]) = tre2_0_0 - tre2_1_0;
}
{
FFTW_REAL tim2_0_0;
FFTW_REAL tim2_1_0;
tim2_0_0 = tim0_0_0 + (((FFTW_REAL) FFTW_K623489801) * (tim0_0_3 + tim0_0_4)) - (((FFTW_REAL) FFTW_K900968867) * (tim0_0_2 + tim0_0_5)) - (((FFTW_REAL) FFTW_K222520933) * (tim0_0_1 + tim0_0_6));
tim2_1_0 = (((FFTW_REAL) FFTW_K974927912) * (tre0_0_1 - tre0_0_6)) + (((FFTW_REAL) FFTW_K433883739) * (tre0_0_5 - tre0_0_2)) + (((FFTW_REAL) FFTW_K781831482) * (tre0_0_4 - tre0_0_3));
c_im(out[2 * ostride]) = tim2_0_0 + tim2_1_0;
c_im(out[12 * ostride]) = tim2_0_0 - tim2_1_0;
}
{
FFTW_REAL tre2_0_0;
FFTW_REAL tre2_1_0;
tre2_0_0 = tre0_0_0 + (((FFTW_REAL) FFTW_K623489801) * (tre0_0_2 + tre0_0_5)) - (((FFTW_REAL) FFTW_K222520933) * (tre0_0_3 + tre0_0_4)) - (((FFTW_REAL) FFTW_K900968867) * (tre0_0_1 + tre0_0_6));
tre2_1_0 = (((FFTW_REAL) FFTW_K433883739) * (tim0_0_6 - tim0_0_1)) + (((FFTW_REAL) FFTW_K781831482) * (tim0_0_2 - tim0_0_5)) + (((FFTW_REAL) FFTW_K974927912) * (tim0_0_4 - tim0_0_3));
c_re(out[10 * ostride]) = tre2_0_0 + tre2_1_0;
c_re(out[4 * ostride]) = tre2_0_0 - tre2_1_0;
}
{
FFTW_REAL tim2_0_0;
FFTW_REAL tim2_1_0;
tim2_0_0 = tim0_0_0 + (((FFTW_REAL) FFTW_K623489801) * (tim0_0_2 + tim0_0_5)) - (((FFTW_REAL) FFTW_K222520933) * (tim0_0_3 + tim0_0_4)) - (((FFTW_REAL) FFTW_K900968867) * (tim0_0_1 + tim0_0_6));
tim2_1_0 = (((FFTW_REAL) FFTW_K433883739) * (tre0_0_1 - tre0_0_6)) + (((FFTW_REAL) FFTW_K781831482) * (tre0_0_5 - tre0_0_2)) + (((FFTW_REAL) FFTW_K974927912) * (tre0_0_3 - tre0_0_4));
c_im(out[10 * ostride]) = tim2_0_0 + tim2_1_0;
c_im(out[4 * ostride]) = tim2_0_0 - tim2_1_0;
}
c_re(out[7 * ostride]) = tre0_1_0 + tre0_1_1 + tre0_1_2 + tre0_1_3 + tre0_1_4 + tre0_1_5 + tre0_1_6;
c_im(out[7 * ostride]) = tim0_1_0 + tim0_1_1 + tim0_1_2 + tim0_1_3 + tim0_1_4 + tim0_1_5 + tim0_1_6;
{
FFTW_REAL tre2_0_0;
FFTW_REAL tre2_1_0;
tre2_0_0 = tre0_1_0 + (((FFTW_REAL) FFTW_K623489801) * (tre0_1_1 + tre0_1_6)) - (((FFTW_REAL) FFTW_K900968867) * (tre0_1_3 + tre0_1_4)) - (((FFTW_REAL) FFTW_K222520933) * (tre0_1_2 + tre0_1_5));
tre2_1_0 = (((FFTW_REAL) FFTW_K781831482) * (tim0_1_6 - tim0_1_1)) + (((FFTW_REAL) FFTW_K974927912) * (tim0_1_5 - tim0_1_2)) + (((FFTW_REAL) FFTW_K433883739) * (tim0_1_4 - tim0_1_3));
c_re(out[ostride]) = tre2_0_0 + tre2_1_0;
c_re(out[13 * ostride]) = tre2_0_0 - tre2_1_0;
}
{
FFTW_REAL tim2_0_0;
FFTW_REAL tim2_1_0;
tim2_0_0 = tim0_1_0 + (((FFTW_REAL) FFTW_K623489801) * (tim0_1_1 + tim0_1_6)) - (((FFTW_REAL) FFTW_K900968867) * (tim0_1_3 + tim0_1_4)) - (((FFTW_REAL) FFTW_K222520933) * (tim0_1_2 + tim0_1_5));
tim2_1_0 = (((FFTW_REAL) FFTW_K781831482) * (tre0_1_1 - tre0_1_6)) + (((FFTW_REAL) FFTW_K974927912) * (tre0_1_2 - tre0_1_5)) + (((FFTW_REAL) FFTW_K433883739) * (tre0_1_3 - tre0_1_4));
c_im(out[ostride]) = tim2_0_0 + tim2_1_0;
c_im(out[13 * ostride]) = tim2_0_0 - tim2_1_0;
}
{
FFTW_REAL tre2_0_0;
FFTW_REAL tre2_1_0;
tre2_0_0 = tre0_1_0 + (((FFTW_REAL) FFTW_K623489801) * (tre0_1_3 + tre0_1_4)) - (((FFTW_REAL) FFTW_K900968867) * (tre0_1_2 + tre0_1_5)) - (((FFTW_REAL) FFTW_K222520933) * (tre0_1_1 + tre0_1_6));
tre2_1_0 = (((FFTW_REAL) FFTW_K974927912) * (tim0_1_6 - tim0_1_1)) + (((FFTW_REAL) FFTW_K433883739) * (tim0_1_2 - tim0_1_5)) + (((FFTW_REAL) FFTW_K781831482) * (tim0_1_3 - tim0_1_4));
c_re(out[9 * ostride]) = tre2_0_0 + tre2_1_0;
c_re(out[5 * ostride]) = tre2_0_0 - tre2_1_0;
}
{
FFTW_REAL tim2_0_0;
FFTW_REAL tim2_1_0;
tim2_0_0 = tim0_1_0 + (((FFTW_REAL) FFTW_K623489801) * (tim0_1_3 + tim0_1_4)) - (((FFTW_REAL) FFTW_K900968867) * (tim0_1_2 + tim0_1_5)) - (((FFTW_REAL) FFTW_K222520933) * (tim0_1_1 + tim0_1_6));
tim2_1_0 = (((FFTW_REAL) FFTW_K974927912) * (tre0_1_1 - tre0_1_6)) + (((FFTW_REAL) FFTW_K433883739) * (tre0_1_5 - tre0_1_2)) + (((FFTW_REAL) FFTW_K781831482) * (tre0_1_4 - tre0_1_3));
c_im(out[9 * ostride]) = tim2_0_0 + tim2_1_0;
c_im(out[5 * ostride]) = tim2_0_0 - tim2_1_0;
}
{
FFTW_REAL tre2_0_0;
FFTW_REAL tre2_1_0;
tre2_0_0 = tre0_1_0 + (((FFTW_REAL) FFTW_K623489801) * (tre0_1_2 + tre0_1_5)) - (((FFTW_REAL) FFTW_K222520933) * (tre0_1_3 + tre0_1_4)) - (((FFTW_REAL) FFTW_K900968867) * (tre0_1_1 + tre0_1_6));
tre2_1_0 = (((FFTW_REAL) FFTW_K433883739) * (tim0_1_6 - tim0_1_1)) + (((FFTW_REAL) FFTW_K781831482) * (tim0_1_2 - tim0_1_5)) + (((FFTW_REAL) FFTW_K974927912) * (tim0_1_4 - tim0_1_3));
c_re(out[3 * ostride]) = tre2_0_0 + tre2_1_0;
c_re(out[11 * ostride]) = tre2_0_0 - tre2_1_0;
}
{
FFTW_REAL tim2_0_0;
FFTW_REAL tim2_1_0;
tim2_0_0 = tim0_1_0 + (((FFTW_REAL) FFTW_K623489801) * (tim0_1_2 + tim0_1_5)) - (((FFTW_REAL) FFTW_K222520933) * (tim0_1_3 + tim0_1_4)) - (((FFTW_REAL) FFTW_K900968867) * (tim0_1_1 + tim0_1_6));
tim2_1_0 = (((FFTW_REAL) FFTW_K433883739) * (tre0_1_1 - tre0_1_6)) + (((FFTW_REAL) FFTW_K781831482) * (tre0_1_5 - tre0_1_2)) + (((FFTW_REAL) FFTW_K974927912) * (tre0_1_3 - tre0_1_4));
c_im(out[3 * ostride]) = tim2_0_0 + tim2_1_0;
c_im(out[11 * ostride]) = tim2_0_0 - tim2_1_0;
}
}
static void r2r_apply(dofft_closure *k_, bench_complex *in, bench_complex *out)
{
dofft_r2r_closure *k = (dofft_r2r_closure *)k_;
bench_problem *p = k->p;
bench_real *ri, *ro;
int n, is, os;
n = p->sz->dims[0].n;
is = p->sz->dims[0].is;
os = p->sz->dims[0].os;
ri = (bench_real *) p->in;
ro = (bench_real *) p->out;
switch (p->k[0]) {
case R2R_R2HC:
cpyr1(n, &c_re(in[0]), 2, ri, is, 1.0);
break;
case R2R_HC2R:
cpyr1(n/2 + 1, &c_re(in[0]), 2, ri, is, 1.0);
cpyr1((n+1)/2 - 1, &c_im(in[n-1]), -2, ri + is*(n-1), -is, 1.0);
break;
case R2R_REDFT00:
cpyr1(n, &c_re(in[0]), 2, ri, is, 1.0);
break;
case R2R_RODFT00:
cpyr1(n, &c_re(in[1]), 2, ri, is, 1.0);
break;
case R2R_REDFT01:
cpyr1(n, &c_re(in[0]), 2, ri, is, 1.0);
break;
case R2R_REDFT10:
cpyr1(n, &c_re(in[1]), 4, ri, is, 1.0);
break;
case R2R_RODFT01:
cpyr1(n, &c_re(in[1]), 2, ri, is, 1.0);
break;
case R2R_RODFT10:
cpyr1(n, &c_im(in[1]), 4, ri, is, 1.0);
break;
case R2R_REDFT11:
cpyr1(n, &c_re(in[1]), 4, ri, is, 1.0);
break;
case R2R_RODFT11:
cpyr1(n, &c_re(in[1]), 4, ri, is, 1.0);
break;
default:
BENCH_ASSERT(0); /* not yet implemented */
}
doit(1, p);
switch (p->k[0]) {
case R2R_R2HC:
if (k->k.recopy_input)
cpyr1(n, ri, is, &c_re(in[0]), 2, 1.0);
cpyr1(n/2 + 1, ro, os, &c_re(out[0]), 2, 1.0);
cpyr1((n+1)/2 - 1, ro + os*(n-1), -os, &c_im(out[1]), 2, 1.0);
c_im(out[0]) = 0.0;
if (n % 2 == 0)
c_im(out[n/2]) = 0.0;
mkhermitian1(out, n);
break;
case R2R_HC2R:
if (k->k.recopy_input) {
cpyr1(n/2 + 1, ri, is, &c_re(in[0]), 2, 1.0);
cpyr1((n+1)/2 - 1, ri + is*(n-1), -is, &c_im(in[1]), 2,1.0);
}
cpyr1(n, ro, os, &c_re(out[0]), 2, 1.0);
mkreal(out, n);
break;
case R2R_REDFT00:
if (k->k.recopy_input)
cpyr1(n, ri, is, &c_re(in[0]), 2, 1.0);
cpyr1(n, ro, os, &c_re(out[0]), 2, 1.0);
mkre00(out, k->n0);
break;
case R2R_RODFT00:
if (k->k.recopy_input)
cpyr1(n, ri, is, &c_im(in[1]), 2, -1.0);
cpyr1(n, ro, os, &c_im(out[1]), 2, -1.0);
mkio00(out, k->n0);
break;
case R2R_REDFT01:
if (k->k.recopy_input)
cpyr1(n, ri, is, &c_re(in[0]), 2, 1.0);
cpyr1(n, ro, os, &c_re(out[1]), 4, 2.0);
mkre10(out, k->n0);
break;
case R2R_REDFT10:
if (k->k.recopy_input)
cpyr1(n, ri, is, &c_re(in[1]), 4, 2.0);
cpyr1(n, ro, os, &c_re(out[0]), 2, 1.0);
mkre01(out, k->n0);
break;
case R2R_RODFT01:
if (k->k.recopy_input)
cpyr1(n, ri, is, &c_re(in[1]), 2, 1.0);
cpyr1(n, ro, os, &c_im(out[1]), 4, -2.0);
mkio10(out, k->n0);
break;
case R2R_RODFT10:
if (k->k.recopy_input)
cpyr1(n, ri, is, &c_im(in[1]), 4, -2.0);
cpyr1(n, ro, os, &c_re(out[1]), 2, 1.0);
mkro01(out, k->n0);
break;
case R2R_REDFT11:
if (k->k.recopy_input)
cpyr1(n, ri, is, &c_re(in[1]), 4, 2.0);
cpyr1(n, ro, os, &c_re(out[1]), 4, 2.0);
mkre11(out, k->n0);
break;
case R2R_RODFT11:
if (k->k.recopy_input)
cpyr1(n, ri, is, &c_im(in[1]), 4, -2.0);
cpyr1(n, ro, os, &c_im(out[1]), 4, -2.0);
mkio11(out, k->n0);
break;
default:
BENCH_ASSERT(0); /* not yet implemented */
}
}
void fftw_hc2hc_forward_9(fftw_real *A, const fftw_complex *W, int iostride, int m, int dist)
{
int i;
fftw_real *X;
fftw_real *Y;
X = A;
Y = A + (9 * iostride);
{
fftw_real tmp136;
fftw_real tmp150;
fftw_real tmp155;
fftw_real tmp154;
fftw_real tmp139;
fftw_real tmp162;
fftw_real tmp145;
fftw_real tmp153;
fftw_real tmp156;
fftw_real tmp137;
fftw_real tmp138;
fftw_real tmp140;
fftw_real tmp151;
ASSERT_ALIGNED_DOUBLE;
tmp136 = X[0];
{
fftw_real tmp146;
fftw_real tmp147;
fftw_real tmp148;
fftw_real tmp149;
ASSERT_ALIGNED_DOUBLE;
tmp146 = X[2 * iostride];
tmp147 = X[5 * iostride];
tmp148 = X[8 * iostride];
tmp149 = tmp147 + tmp148;
tmp150 = tmp146 + tmp149;
tmp155 = tmp146 - (K500000000 * tmp149);
tmp154 = tmp148 - tmp147;
}
tmp137 = X[3 * iostride];
tmp138 = X[6 * iostride];
tmp139 = tmp137 + tmp138;
tmp162 = tmp138 - tmp137;
{
fftw_real tmp141;
fftw_real tmp142;
fftw_real tmp143;
fftw_real tmp144;
ASSERT_ALIGNED_DOUBLE;
tmp141 = X[iostride];
tmp142 = X[4 * iostride];
tmp143 = X[7 * iostride];
tmp144 = tmp142 + tmp143;
tmp145 = tmp141 + tmp144;
tmp153 = tmp141 - (K500000000 * tmp144);
tmp156 = tmp143 - tmp142;
}
Y[-3 * iostride] = K866025403 * (tmp150 - tmp145);
tmp140 = tmp136 + tmp139;
tmp151 = tmp145 + tmp150;
X[3 * iostride] = tmp140 - (K500000000 * tmp151);
X[0] = tmp140 + tmp151;
{
fftw_real tmp164;
fftw_real tmp160;
fftw_real tmp161;
fftw_real tmp163;
fftw_real tmp152;
fftw_real tmp157;
fftw_real tmp158;
fftw_real tmp159;
ASSERT_ALIGNED_DOUBLE;
tmp164 = K866025403 * tmp162;
tmp160 = (K663413948 * tmp156) - (K642787609 * tmp153);
tmp161 = (K150383733 * tmp154) - (K984807753 * tmp155);
tmp163 = tmp160 + tmp161;
tmp152 = tmp136 - (K500000000 * tmp139);
tmp157 = (K766044443 * tmp153) + (K556670399 * tmp156);
tmp158 = (K173648177 * tmp155) + (K852868531 * tmp154);
tmp159 = tmp157 + tmp158;
X[iostride] = tmp152 + tmp159;
X[4 * iostride] = tmp152 + (K866025403 * (tmp160 - tmp161)) - (K500000000 * tmp159);
X[2 * iostride] = tmp152 + (K173648177 * tmp153) - (K296198132 * tmp154) - (K939692620 * tmp155) - (K852868531 * tmp156);
Y[-iostride] = tmp164 + tmp163;
Y[-4 * iostride] = (K866025403 * (tmp162 + (tmp158 - tmp157))) - (K500000000 * tmp163);
Y[-2 * iostride] = (K813797681 * tmp154) - (K342020143 * tmp155) - (K150383733 * tmp156) - (K984807753 * tmp153) - tmp164;
}
}
X = X + dist;
Y = Y - dist;
for (i = 2; i < m; i = i + 2, X = X + dist, Y = Y - dist, W = W + 8) {
fftw_real tmp24;
fftw_real tmp122;
fftw_real tmp75;
fftw_real tmp121;
fftw_real tmp128;
fftw_real tmp127;
fftw_real tmp35;
fftw_real tmp72;
fftw_real tmp70;
fftw_real tmp92;
fftw_real tmp109;
fftw_real tmp118;
fftw_real tmp97;
fftw_real tmp108;
fftw_real tmp53;
fftw_real tmp81;
fftw_real tmp105;
fftw_real tmp117;
fftw_real tmp86;
fftw_real tmp106;
ASSERT_ALIGNED_DOUBLE;
{
fftw_real tmp29;
fftw_real tmp73;
fftw_real tmp34;
fftw_real tmp74;
ASSERT_ALIGNED_DOUBLE;
tmp24 = X[0];
tmp122 = Y[-8 * iostride];
{
fftw_real tmp26;
fftw_real tmp28;
fftw_real tmp25;
fftw_real tmp27;
ASSERT_ALIGNED_DOUBLE;
tmp26 = X[3 * iostride];
tmp28 = Y[-5 * iostride];
tmp25 = c_re(W[2]);
tmp27 = c_im(W[2]);
tmp29 = (tmp25 * tmp26) - (tmp27 * tmp28);
tmp73 = (tmp27 * tmp26) + (tmp25 * tmp28);
}
{
fftw_real tmp31;
fftw_real tmp33;
fftw_real tmp30;
fftw_real tmp32;
ASSERT_ALIGNED_DOUBLE;
tmp31 = X[6 * iostride];
tmp33 = Y[-2 * iostride];
tmp30 = c_re(W[5]);
tmp32 = c_im(W[5]);
tmp34 = (tmp30 * tmp31) - (tmp32 * tmp33);
tmp74 = (tmp32 * tmp31) + (tmp30 * tmp33);
}
tmp75 = K866025403 * (tmp73 - tmp74);
tmp121 = tmp73 + tmp74;
tmp128 = tmp122 - (K500000000 * tmp121);
tmp127 = K866025403 * (tmp34 - tmp29);
tmp35 = tmp29 + tmp34;
tmp72 = tmp24 - (K500000000 * tmp35);
}
{
fftw_real tmp58;
fftw_real tmp94;
fftw_real tmp63;
fftw_real tmp89;
fftw_real tmp68;
fftw_real tmp90;
fftw_real tmp69;
fftw_real tmp95;
ASSERT_ALIGNED_DOUBLE;
{
fftw_real tmp55;
fftw_real tmp57;
fftw_real tmp54;
fftw_real tmp56;
ASSERT_ALIGNED_DOUBLE;
tmp55 = X[2 * iostride];
tmp57 = Y[-6 * iostride];
tmp54 = c_re(W[1]);
tmp56 = c_im(W[1]);
tmp58 = (tmp54 * tmp55) - (tmp56 * tmp57);
tmp94 = (tmp56 * tmp55) + (tmp54 * tmp57);
}
{
fftw_real tmp60;
fftw_real tmp62;
fftw_real tmp59;
fftw_real tmp61;
ASSERT_ALIGNED_DOUBLE;
tmp60 = X[5 * iostride];
tmp62 = Y[-3 * iostride];
tmp59 = c_re(W[4]);
tmp61 = c_im(W[4]);
tmp63 = (tmp59 * tmp60) - (tmp61 * tmp62);
tmp89 = (tmp61 * tmp60) + (tmp59 * tmp62);
}
{
fftw_real tmp65;
fftw_real tmp67;
fftw_real tmp64;
fftw_real tmp66;
ASSERT_ALIGNED_DOUBLE;
tmp65 = X[8 * iostride];
tmp67 = Y[0];
tmp64 = c_re(W[7]);
tmp66 = c_im(W[7]);
tmp68 = (tmp64 * tmp65) - (tmp66 * tmp67);
tmp90 = (tmp66 * tmp65) + (tmp64 * tmp67);
}
tmp69 = tmp63 + tmp68;
tmp95 = tmp89 + tmp90;
{
fftw_real tmp88;
fftw_real tmp91;
fftw_real tmp93;
fftw_real tmp96;
ASSERT_ALIGNED_DOUBLE;
tmp70 = tmp58 + tmp69;
tmp88 = tmp58 - (K500000000 * tmp69);
tmp91 = K866025403 * (tmp89 - tmp90);
tmp92 = tmp88 + tmp91;
tmp109 = tmp88 - tmp91;
tmp118 = tmp94 + tmp95;
tmp93 = K866025403 * (tmp68 - tmp63);
tmp96 = tmp94 - (K500000000 * tmp95);
tmp97 = tmp93 + tmp96;
tmp108 = tmp96 - tmp93;
}
}
{
fftw_real tmp41;
fftw_real tmp83;
fftw_real tmp46;
fftw_real tmp78;
fftw_real tmp51;
fftw_real tmp79;
fftw_real tmp52;
fftw_real tmp84;
ASSERT_ALIGNED_DOUBLE;
{
fftw_real tmp38;
fftw_real tmp40;
fftw_real tmp37;
fftw_real tmp39;
ASSERT_ALIGNED_DOUBLE;
tmp38 = X[iostride];
tmp40 = Y[-7 * iostride];
tmp37 = c_re(W[0]);
tmp39 = c_im(W[0]);
tmp41 = (tmp37 * tmp38) - (tmp39 * tmp40);
tmp83 = (tmp39 * tmp38) + (tmp37 * tmp40);
}
{
fftw_real tmp43;
fftw_real tmp45;
fftw_real tmp42;
fftw_real tmp44;
ASSERT_ALIGNED_DOUBLE;
tmp43 = X[4 * iostride];
tmp45 = Y[-4 * iostride];
tmp42 = c_re(W[3]);
tmp44 = c_im(W[3]);
tmp46 = (tmp42 * tmp43) - (tmp44 * tmp45);
tmp78 = (tmp44 * tmp43) + (tmp42 * tmp45);
}
{
fftw_real tmp48;
fftw_real tmp50;
fftw_real tmp47;
fftw_real tmp49;
ASSERT_ALIGNED_DOUBLE;
tmp48 = X[7 * iostride];
tmp50 = Y[-iostride];
tmp47 = c_re(W[6]);
tmp49 = c_im(W[6]);
tmp51 = (tmp47 * tmp48) - (tmp49 * tmp50);
tmp79 = (tmp49 * tmp48) + (tmp47 * tmp50);
}
tmp52 = tmp46 + tmp51;
tmp84 = tmp78 + tmp79;
{
fftw_real tmp77;
fftw_real tmp80;
fftw_real tmp82;
fftw_real tmp85;
ASSERT_ALIGNED_DOUBLE;
tmp53 = tmp41 + tmp52;
tmp77 = tmp41 - (K500000000 * tmp52);
tmp80 = K866025403 * (tmp78 - tmp79);
tmp81 = tmp77 + tmp80;
tmp105 = tmp77 - tmp80;
tmp117 = tmp83 + tmp84;
tmp82 = K866025403 * (tmp51 - tmp46);
tmp85 = tmp83 - (K500000000 * tmp84);
tmp86 = tmp82 + tmp85;
tmp106 = tmp85 - tmp82;
}
}
{
fftw_real tmp119;
fftw_real tmp36;
fftw_real tmp71;
fftw_real tmp116;
ASSERT_ALIGNED_DOUBLE;
tmp119 = K866025403 * (tmp117 - tmp118);
tmp36 = tmp24 + tmp35;
tmp71 = tmp53 + tmp70;
tmp116 = tmp36 - (K500000000 * tmp71);
X[0] = tmp36 + tmp71;
X[3 * iostride] = tmp116 + tmp119;
Y[-6 * iostride] = tmp116 - tmp119;
}
{
fftw_real tmp125;
fftw_real tmp120;
fftw_real tmp123;
fftw_real tmp124;
ASSERT_ALIGNED_DOUBLE;
tmp125 = K866025403 * (tmp70 - tmp53);
tmp120 = tmp117 + tmp118;
tmp123 = tmp121 + tmp122;
tmp124 = tmp123 - (K500000000 * tmp120);
Y[0] = tmp120 + tmp123;
Y[-3 * iostride] = tmp125 + tmp124;
X[6 * iostride] = -(tmp124 - tmp125);
}
{
fftw_real tmp76;
fftw_real tmp129;
fftw_real tmp99;
fftw_real tmp131;
fftw_real tmp103;
fftw_real tmp126;
fftw_real tmp100;
fftw_real tmp130;
ASSERT_ALIGNED_DOUBLE;
tmp76 = tmp72 + tmp75;
tmp129 = tmp127 + tmp128;
{
fftw_real tmp87;
fftw_real tmp98;
fftw_real tmp101;
fftw_real tmp102;
ASSERT_ALIGNED_DOUBLE;
tmp87 = (K766044443 * tmp81) + (K642787609 * tmp86);
tmp98 = (K173648177 * tmp92) + (K984807753 * tmp97);
tmp99 = tmp87 + tmp98;
tmp131 = K866025403 * (tmp98 - tmp87);
tmp101 = (K766044443 * tmp86) - (K642787609 * tmp81);
tmp102 = (K173648177 * tmp97) - (K984807753 * tmp92);
tmp103 = K866025403 * (tmp101 - tmp102);
tmp126 = tmp101 + tmp102;
}
X[iostride] = tmp76 + tmp99;
tmp100 = tmp76 - (K500000000 * tmp99);
Y[-7 * iostride] = tmp100 - tmp103;
X[4 * iostride] = tmp100 + tmp103;
Y[-iostride] = tmp126 + tmp129;
tmp130 = tmp129 - (K500000000 * tmp126);
X[7 * iostride] = -(tmp130 - tmp131);
Y[-4 * iostride] = tmp131 + tmp130;
}
{
fftw_real tmp104;
fftw_real tmp133;
fftw_real tmp111;
fftw_real tmp132;
fftw_real tmp115;
fftw_real tmp134;
fftw_real tmp112;
fftw_real tmp135;
ASSERT_ALIGNED_DOUBLE;
tmp104 = tmp72 - tmp75;
tmp133 = tmp128 - tmp127;
{
fftw_real tmp107;
fftw_real tmp110;
fftw_real tmp113;
fftw_real tmp114;
ASSERT_ALIGNED_DOUBLE;
tmp107 = (K173648177 * tmp105) + (K984807753 * tmp106);
tmp110 = (K342020143 * tmp108) - (K939692620 * tmp109);
tmp111 = tmp107 + tmp110;
tmp132 = K866025403 * (tmp110 - tmp107);
tmp113 = (K173648177 * tmp106) - (K984807753 * tmp105);
tmp114 = (K342020143 * tmp109) + (K939692620 * tmp108);
tmp115 = K866025403 * (tmp113 + tmp114);
tmp134 = tmp113 - tmp114;
}
X[2 * iostride] = tmp104 + tmp111;
tmp112 = tmp104 - (K500000000 * tmp111);
Y[-8 * iostride] = tmp112 - tmp115;
Y[-5 * iostride] = tmp112 + tmp115;
Y[-2 * iostride] = tmp134 + tmp133;
tmp135 = tmp133 - (K500000000 * tmp134);
X[5 * iostride] = -(tmp132 + tmp135);
X[8 * iostride] = -(tmp135 - tmp132);
}
}
if (i == m) {
fftw_real tmp12;
fftw_real tmp18;
fftw_real tmp4;
fftw_real tmp7;
fftw_real tmp10;
fftw_real tmp9;
fftw_real tmp14;
fftw_real tmp23;
fftw_real tmp16;
fftw_real tmp21;
fftw_real tmp5;
fftw_real tmp8;
fftw_real tmp6;
fftw_real tmp11;
fftw_real tmp22;
fftw_real tmp13;
fftw_real tmp17;
fftw_real tmp20;
fftw_real tmp1;
fftw_real tmp3;
fftw_real tmp2;
fftw_real tmp15;
fftw_real tmp19;
ASSERT_ALIGNED_DOUBLE;
tmp1 = X[0];
tmp3 = X[3 * iostride];
tmp2 = X[6 * iostride];
tmp12 = K866025403 * (tmp3 + tmp2);
tmp18 = tmp1 - (K500000000 * (tmp2 - tmp3));
tmp4 = tmp1 + tmp2 - tmp3;
tmp7 = X[4 * iostride];
tmp10 = X[7 * iostride];
tmp9 = X[iostride];
tmp14 = (K1_969615506 * tmp7) + (K684040286 * tmp9) + (K1_285575219 * tmp10);
tmp23 = (K1_285575219 * tmp9) - (K1_969615506 * tmp10) - (K684040286 * tmp7);
tmp16 = (K347296355 * tmp7) + (K1_879385241 * tmp9) - (K1_532088886 * tmp10);
tmp21 = (K1_879385241 * tmp7) + (K1_532088886 * tmp9) + (K347296355 * tmp10);
tmp5 = X[2 * iostride];
tmp8 = X[5 * iostride];
tmp6 = X[8 * iostride];
tmp11 = tmp8 - (tmp5 + tmp6);
tmp22 = (K1_285575219 * tmp6) - (K684040286 * tmp8) - (K1_969615506 * tmp5);
tmp13 = (K1_285575219 * tmp5) + (K1_969615506 * tmp8) + (K684040286 * tmp6);
tmp17 = (K1_532088886 * tmp5) - (K1_879385241 * tmp6) - (K347296355 * tmp8);
tmp20 = (K347296355 * tmp5) + (K1_879385241 * tmp8) + (K1_532088886 * tmp6);
Y[-iostride] = K866025403 * (tmp11 + tmp7 - (tmp9 + tmp10));
X[iostride] = tmp4 + (K500000000 * (tmp11 + tmp9 + tmp10 - tmp7));
X[4 * iostride] = tmp4 + tmp5 + tmp6 + tmp7 - (tmp8 + tmp9 + tmp10);
X[2 * iostride] = tmp18 + (K433012701 * (tmp22 - tmp23)) + (K250000000 * (tmp21 - tmp20));
Y[-2 * iostride] = tmp12 - (K433012701 * (tmp20 + tmp21)) - (K250000000 * (tmp22 + tmp23));
tmp15 = tmp13 + tmp14;
Y[0] = -(tmp12 + (K500000000 * tmp15));
Y[-3 * iostride] = (K250000000 * tmp15) - (K433012701 * (tmp16 - tmp17)) - tmp12;
tmp19 = tmp17 + tmp16;
X[0] = tmp18 + (K500000000 * tmp19);
X[3 * iostride] = tmp18 + (K433012701 * (tmp13 - tmp14)) - (K250000000 * tmp19);
}
}
void fftwi_no_twiddle_11(const fftw_complex *input, fftw_complex *output,
int istride, int ostride)
{
fftw_real tmp1;
fftw_real tmp23;
fftw_real tmp4;
fftw_real tmp17;
fftw_real tmp32;
fftw_real tmp51;
fftw_real tmp38;
fftw_real tmp53;
fftw_real tmp7;
fftw_real tmp21;
fftw_real tmp10;
fftw_real tmp18;
fftw_real tmp29;
fftw_real tmp50;
fftw_real tmp13;
fftw_real tmp19;
fftw_real tmp35;
fftw_real tmp49;
fftw_real tmp26;
fftw_real tmp52;
fftw_real tmp16;
fftw_real tmp20;
ASSERT_ALIGNED_DOUBLE;
{
fftw_real tmp2;
fftw_real tmp3;
fftw_real tmp30;
fftw_real tmp31;
ASSERT_ALIGNED_DOUBLE;
tmp1 = c_re(input[0]);
tmp23 = c_im(input[0]);
tmp2 = c_re(input[istride]);
tmp3 = c_re(input[10 * istride]);
tmp4 = tmp2 + tmp3;
tmp17 = tmp2 - tmp3;
tmp30 = c_im(input[istride]);
tmp31 = c_im(input[10 * istride]);
tmp32 = tmp30 + tmp31;
tmp51 = tmp31 - tmp30;
{
fftw_real tmp36;
fftw_real tmp37;
fftw_real tmp5;
fftw_real tmp6;
ASSERT_ALIGNED_DOUBLE;
tmp36 = c_im(input[2 * istride]);
tmp37 = c_im(input[9 * istride]);
tmp38 = tmp36 + tmp37;
tmp53 = tmp37 - tmp36;
tmp5 = c_re(input[2 * istride]);
tmp6 = c_re(input[9 * istride]);
tmp7 = tmp5 + tmp6;
tmp21 = tmp5 - tmp6;
}
}
{
fftw_real tmp8;
fftw_real tmp9;
fftw_real tmp33;
fftw_real tmp34;
ASSERT_ALIGNED_DOUBLE;
tmp8 = c_re(input[3 * istride]);
tmp9 = c_re(input[8 * istride]);
tmp10 = tmp8 + tmp9;
tmp18 = tmp8 - tmp9;
{
fftw_real tmp27;
fftw_real tmp28;
fftw_real tmp11;
fftw_real tmp12;
ASSERT_ALIGNED_DOUBLE;
tmp27 = c_im(input[3 * istride]);
tmp28 = c_im(input[8 * istride]);
tmp29 = tmp27 + tmp28;
tmp50 = tmp28 - tmp27;
tmp11 = c_re(input[4 * istride]);
tmp12 = c_re(input[7 * istride]);
tmp13 = tmp11 + tmp12;
tmp19 = tmp11 - tmp12;
}
tmp33 = c_im(input[4 * istride]);
tmp34 = c_im(input[7 * istride]);
tmp35 = tmp33 + tmp34;
tmp49 = tmp34 - tmp33;
{
fftw_real tmp24;
fftw_real tmp25;
fftw_real tmp14;
fftw_real tmp15;
ASSERT_ALIGNED_DOUBLE;
tmp24 = c_im(input[5 * istride]);
tmp25 = c_im(input[6 * istride]);
tmp26 = tmp24 + tmp25;
tmp52 = tmp25 - tmp24;
tmp14 = c_re(input[5 * istride]);
tmp15 = c_re(input[6 * istride]);
tmp16 = tmp14 + tmp15;
tmp20 = tmp14 - tmp15;
}
}
{
fftw_real tmp56;
fftw_real tmp55;
fftw_real tmp44;
fftw_real tmp45;
ASSERT_ALIGNED_DOUBLE;
c_re(output[0]) = tmp1 + tmp4 + tmp7 + tmp10 + tmp13 + tmp16;
{
fftw_real tmp62;
fftw_real tmp61;
fftw_real tmp58;
fftw_real tmp57;
ASSERT_ALIGNED_DOUBLE;
tmp62 =
(K989821441 * tmp52) + (K755749574 * tmp50) +
(K281732556 * tmp51) - (K909631995 * tmp49) -
(K540640817 * tmp53);
tmp61 =
tmp1 + (K841253532 * tmp7) + (K415415013 * tmp13) -
(K142314838 * tmp16) - (K654860733 * tmp10) -
(K959492973 * tmp4);
c_re(output[6 * ostride]) = tmp61 - tmp62;
c_re(output[5 * ostride]) = tmp61 + tmp62;
tmp58 =
(K909631995 * tmp53) + (K755749574 * tmp49) +
(K281732556 * tmp52) + (K989821441 * tmp50) +
(K540640817 * tmp51);
tmp57 =
tmp1 + (K841253532 * tmp4) + (K415415013 * tmp7) -
(K959492973 * tmp16) - (K654860733 * tmp13) -
(K142314838 * tmp10);
c_re(output[10 * ostride]) = tmp57 - tmp58;
c_re(output[ostride]) = tmp57 + tmp58;
}
tmp56 =
(K755749574 * tmp53) + (K909631995 * tmp51) -
(K281732556 * tmp50) - (K540640817 * tmp52) -
(K989821441 * tmp49);
tmp55 =
tmp1 + (K415415013 * tmp4) + (K841253532 * tmp16) -
(K142314838 * tmp13) - (K959492973 * tmp10) -
(K654860733 * tmp7);
c_re(output[9 * ostride]) = tmp55 - tmp56;
c_re(output[2 * ostride]) = tmp55 + tmp56;
{
fftw_real tmp60;
fftw_real tmp59;
fftw_real tmp54;
fftw_real tmp48;
ASSERT_ALIGNED_DOUBLE;
tmp60 =
(K540640817 * tmp49) + (K755749574 * tmp52) +
(K989821441 * tmp51) - (K909631995 * tmp50) -
(K281732556 * tmp53);
tmp59 =
tmp1 + (K415415013 * tmp10) + (K841253532 * tmp13) -
(K654860733 * tmp16) - (K959492973 * tmp7) -
(K142314838 * tmp4);
c_re(output[8 * ostride]) = tmp59 - tmp60;
c_re(output[3 * ostride]) = tmp59 + tmp60;
tmp54 =
(K281732556 * tmp49) + (K540640817 * tmp50) +
(K755749574 * tmp51) - (K909631995 * tmp52) -
(K989821441 * tmp53);
tmp48 =
tmp1 + (K841253532 * tmp10) + (K415415013 * tmp16) -
(K959492973 * tmp13) - (K142314838 * tmp7) -
(K654860733 * tmp4);
c_re(output[7 * ostride]) = tmp48 - tmp54;
c_re(output[4 * ostride]) = tmp48 + tmp54;
}
c_im(output[0]) = tmp23 + tmp38 + tmp35 + tmp26 + tmp29 + tmp32;
{
fftw_real tmp22;
fftw_real tmp39;
fftw_real tmp42;
fftw_real tmp43;
ASSERT_ALIGNED_DOUBLE;
tmp22 =
(K755749574 * tmp17) + (K540640817 * tmp18) +
(K281732556 * tmp19) - (K909631995 * tmp20) -
(K989821441 * tmp21);
tmp39 =
tmp23 + (K415415013 * tmp26) + (K841253532 * tmp29) -
(K654860733 * tmp32) - (K959492973 * tmp35) -
(K142314838 * tmp38);
c_im(output[4 * ostride]) = tmp22 + tmp39;
c_im(output[7 * ostride]) = tmp39 - tmp22;
tmp42 =
(K281732556 * tmp17) + (K755749574 * tmp18) +
(K989821441 * tmp20) - (K909631995 * tmp19) -
(K540640817 * tmp21);
tmp43 =
tmp23 + (K841253532 * tmp38) + (K415415013 * tmp35) -
(K959492973 * tmp32) - (K654860733 * tmp29) -
(K142314838 * tmp26);
c_im(output[5 * ostride]) = tmp42 + tmp43;
c_im(output[6 * ostride]) = tmp43 - tmp42;
}
tmp44 =
(K540640817 * tmp17) + (K909631995 * tmp21) +
(K989821441 * tmp18) + (K755749574 * tmp19) +
(K281732556 * tmp20);
tmp45 =
tmp23 + (K415415013 * tmp38) + (K841253532 * tmp32) -
(K142314838 * tmp29) - (K959492973 * tmp26) -
(K654860733 * tmp35);
c_im(output[ostride]) = tmp44 + tmp45;
c_im(output[10 * ostride]) = tmp45 - tmp44;
{
fftw_real tmp40;
fftw_real tmp41;
fftw_real tmp46;
fftw_real tmp47;
ASSERT_ALIGNED_DOUBLE;
tmp40 =
(K989821441 * tmp17) + (K540640817 * tmp19) +
(K755749574 * tmp20) - (K909631995 * tmp18) -
(K281732556 * tmp21);
tmp41 =
tmp23 + (K841253532 * tmp35) + (K415415013 * tmp29) -
(K142314838 * tmp32) - (K654860733 * tmp26) -
(K959492973 * tmp38);
c_im(output[3 * ostride]) = tmp40 + tmp41;
c_im(output[8 * ostride]) = tmp41 - tmp40;
tmp46 =
(K909631995 * tmp17) + (K755749574 * tmp21) -
(K540640817 * tmp20) - (K989821441 * tmp19) -
(K281732556 * tmp18);
tmp47 =
tmp23 + (K841253532 * tmp26) + (K415415013 * tmp32) -
(K959492973 * tmp29) - (K142314838 * tmp35) -
(K654860733 * tmp38);
c_im(output[2 * ostride]) = tmp46 + tmp47;
c_im(output[9 * ostride]) = tmp47 - tmp46;
}
}
}
void test_in_place(int n, int istride, int howmany, fftw_direction dir,
fftw_plan validated_plan, int specific)
{
fftw_complex *in1, *in2, *out2;
fftw_plan plan;
int i, j;
int flags = measure_flag | wisdom_flag | FFTW_IN_PLACE;
if (coinflip())
flags |= FFTW_THREADSAFE;
in1 = (fftw_complex *) fftw_malloc(istride * n * sizeof(fftw_complex) * howmany);
in2 = (fftw_complex *) fftw_malloc(n * sizeof(fftw_complex) * howmany);
out2 = (fftw_complex *) fftw_malloc(n * sizeof(fftw_complex) * howmany);
if (!specific)
plan = fftw_create_plan(n, dir, flags);
else
plan = fftw_create_plan_specific(n, dir, flags,
in1, istride,
(fftw_complex *) NULL, 0);
/* generate random inputs */
for (i = 0; i < n * howmany; ++i) {
c_re(in1[i * istride]) = c_re(in2[i]) = DRAND();
c_im(in1[i * istride]) = c_im(in2[i]) = DRAND();
}
/*
* fill in other positions of the array, to make sure that
* fftw doesn't overwrite them
*/
for (j = 1; j < istride; ++j)
for (i = 0; i < n * howmany; ++i) {
c_re(in1[i * istride + j]) = i * istride + j;
c_im(in1[i * istride + j]) = i * istride - j;
}
CHECK(plan != NULL, "can't create plan");
WHEN_VERBOSE(2, fftw_print_plan(plan));
/* fft-ize */
if (howmany != 1 || istride != 1 || coinflip())
fftw_threads(nthreads, plan, howmany, in1, istride, n * istride,
(fftw_complex *) NULL, 0, 0);
else
fftw_threads_one(nthreads, plan, in1, NULL);
fftw_destroy_plan(plan);
/* check for overwriting */
for (j = 1; j < istride; ++j)
for (i = 0; i < n * howmany; ++i)
CHECK(c_re(in1[i * istride + j]) == i * istride + j &&
c_im(in1[i * istride + j]) == i * istride - j,
"input has been overwritten");
for (i = 0; i < howmany; ++i) {
fftw(validated_plan, 1, in2 + n * i, 1, n, out2 + n * i, 1, n);
}
CHECK(compute_error_complex(in1, istride, out2, 1, n * howmany) < TOLERANCE,
"test_in_place: wrong answer");
WHEN_VERBOSE(2, printf("OK\n"));
fftw_free(in1);
fftw_free(in2);
fftw_free(out2);
}
void fftw_no_twiddle_12(const fftw_complex *input, fftw_complex *output,
int istride, int ostride)
{
fftw_real tmp5;
fftw_real tmp53;
fftw_real tmp36;
fftw_real tmp28;
fftw_real tmp35;
fftw_real tmp54;
fftw_real tmp10;
fftw_real tmp56;
fftw_real tmp39;
fftw_real tmp33;
fftw_real tmp38;
fftw_real tmp57;
fftw_real tmp16;
fftw_real tmp42;
fftw_real tmp72;
fftw_real tmp45;
fftw_real tmp92;
fftw_real tmp75;
fftw_real tmp21;
fftw_real tmp47;
fftw_real tmp77;
fftw_real tmp50;
fftw_real tmp93;
fftw_real tmp80;
ASSERT_ALIGNED_DOUBLE;
{
fftw_real tmp1;
fftw_real tmp2;
fftw_real tmp3;
fftw_real tmp4;
ASSERT_ALIGNED_DOUBLE;
tmp1 = c_re(input[0]);
tmp2 = c_re(input[4 * istride]);
tmp3 = c_re(input[8 * istride]);
tmp4 = tmp2 + tmp3;
tmp5 = tmp1 + tmp4;
tmp53 = tmp1 - (K500000000 * tmp4);
tmp36 = K866025403 * (tmp3 - tmp2);
}
{
fftw_real tmp24;
fftw_real tmp25;
fftw_real tmp26;
fftw_real tmp27;
ASSERT_ALIGNED_DOUBLE;
tmp24 = c_im(input[0]);
tmp25 = c_im(input[4 * istride]);
tmp26 = c_im(input[8 * istride]);
tmp27 = tmp25 + tmp26;
tmp28 = tmp24 + tmp27;
tmp35 = tmp24 - (K500000000 * tmp27);
tmp54 = K866025403 * (tmp25 - tmp26);
}
{
fftw_real tmp6;
fftw_real tmp7;
fftw_real tmp8;
fftw_real tmp9;
ASSERT_ALIGNED_DOUBLE;
tmp6 = c_re(input[6 * istride]);
tmp7 = c_re(input[10 * istride]);
tmp8 = c_re(input[2 * istride]);
tmp9 = tmp7 + tmp8;
tmp10 = tmp6 + tmp9;
tmp56 = tmp6 - (K500000000 * tmp9);
tmp39 = K866025403 * (tmp8 - tmp7);
}
{
fftw_real tmp29;
fftw_real tmp30;
fftw_real tmp31;
fftw_real tmp32;
ASSERT_ALIGNED_DOUBLE;
tmp29 = c_im(input[6 * istride]);
tmp30 = c_im(input[10 * istride]);
tmp31 = c_im(input[2 * istride]);
tmp32 = tmp30 + tmp31;
tmp33 = tmp29 + tmp32;
tmp38 = tmp29 - (K500000000 * tmp32);
tmp57 = K866025403 * (tmp30 - tmp31);
}
{
fftw_real tmp12;
fftw_real tmp13;
fftw_real tmp14;
fftw_real tmp15;
ASSERT_ALIGNED_DOUBLE;
tmp12 = c_re(input[3 * istride]);
tmp13 = c_re(input[7 * istride]);
tmp14 = c_re(input[11 * istride]);
tmp15 = tmp13 + tmp14;
tmp16 = tmp12 + tmp15;
tmp42 = tmp12 - (K500000000 * tmp15);
tmp72 = K866025403 * (tmp14 - tmp13);
}
{
fftw_real tmp73;
fftw_real tmp43;
fftw_real tmp44;
fftw_real tmp74;
ASSERT_ALIGNED_DOUBLE;
tmp73 = c_im(input[3 * istride]);
tmp43 = c_im(input[7 * istride]);
tmp44 = c_im(input[11 * istride]);
tmp74 = tmp43 + tmp44;
tmp45 = K866025403 * (tmp43 - tmp44);
tmp92 = tmp73 + tmp74;
tmp75 = tmp73 - (K500000000 * tmp74);
}
{
fftw_real tmp17;
fftw_real tmp18;
fftw_real tmp19;
fftw_real tmp20;
ASSERT_ALIGNED_DOUBLE;
tmp17 = c_re(input[9 * istride]);
tmp18 = c_re(input[istride]);
tmp19 = c_re(input[5 * istride]);
tmp20 = tmp18 + tmp19;
tmp21 = tmp17 + tmp20;
tmp47 = tmp17 - (K500000000 * tmp20);
tmp77 = K866025403 * (tmp19 - tmp18);
}
{
fftw_real tmp78;
fftw_real tmp48;
fftw_real tmp49;
fftw_real tmp79;
ASSERT_ALIGNED_DOUBLE;
tmp78 = c_im(input[9 * istride]);
tmp48 = c_im(input[istride]);
tmp49 = c_im(input[5 * istride]);
tmp79 = tmp48 + tmp49;
tmp50 = K866025403 * (tmp48 - tmp49);
tmp93 = tmp78 + tmp79;
tmp80 = tmp78 - (K500000000 * tmp79);
}
{
fftw_real tmp11;
fftw_real tmp22;
fftw_real tmp23;
fftw_real tmp34;
ASSERT_ALIGNED_DOUBLE;
tmp11 = tmp5 + tmp10;
tmp22 = tmp16 + tmp21;
c_re(output[6 * ostride]) = tmp11 - tmp22;
c_re(output[0]) = tmp11 + tmp22;
{
fftw_real tmp91;
fftw_real tmp94;
fftw_real tmp95;
fftw_real tmp96;
ASSERT_ALIGNED_DOUBLE;
tmp91 = tmp5 - tmp10;
tmp94 = tmp92 - tmp93;
c_re(output[3 * ostride]) = tmp91 - tmp94;
c_re(output[9 * ostride]) = tmp91 + tmp94;
tmp95 = tmp28 + tmp33;
tmp96 = tmp92 + tmp93;
c_im(output[6 * ostride]) = tmp95 - tmp96;
c_im(output[0]) = tmp95 + tmp96;
}
tmp23 = tmp16 - tmp21;
tmp34 = tmp28 - tmp33;
c_im(output[3 * ostride]) = tmp23 + tmp34;
c_im(output[9 * ostride]) = tmp34 - tmp23;
{
fftw_real tmp63;
fftw_real tmp83;
fftw_real tmp82;
fftw_real tmp84;
fftw_real tmp66;
fftw_real tmp70;
fftw_real tmp69;
fftw_real tmp71;
ASSERT_ALIGNED_DOUBLE;
{
fftw_real tmp61;
fftw_real tmp62;
fftw_real tmp76;
fftw_real tmp81;
ASSERT_ALIGNED_DOUBLE;
tmp61 = tmp36 + tmp35;
tmp62 = tmp39 + tmp38;
tmp63 = tmp61 - tmp62;
tmp83 = tmp61 + tmp62;
tmp76 = tmp72 + tmp75;
tmp81 = tmp77 + tmp80;
tmp82 = tmp76 - tmp81;
tmp84 = tmp76 + tmp81;
}
{
fftw_real tmp64;
fftw_real tmp65;
fftw_real tmp67;
fftw_real tmp68;
ASSERT_ALIGNED_DOUBLE;
tmp64 = tmp42 + tmp45;
tmp65 = tmp47 + tmp50;
tmp66 = tmp64 - tmp65;
tmp70 = tmp64 + tmp65;
tmp67 = tmp53 + tmp54;
tmp68 = tmp56 + tmp57;
tmp69 = tmp67 + tmp68;
tmp71 = tmp67 - tmp68;
}
c_im(output[ostride]) = tmp63 - tmp66;
c_im(output[7 * ostride]) = tmp63 + tmp66;
c_re(output[10 * ostride]) = tmp69 - tmp70;
c_re(output[4 * ostride]) = tmp69 + tmp70;
c_re(output[7 * ostride]) = tmp71 - tmp82;
c_re(output[ostride]) = tmp71 + tmp82;
c_im(output[10 * ostride]) = tmp83 - tmp84;
c_im(output[4 * ostride]) = tmp83 + tmp84;
}
{
fftw_real tmp41;
fftw_real tmp89;
fftw_real tmp88;
fftw_real tmp90;
fftw_real tmp52;
fftw_real tmp60;
fftw_real tmp59;
fftw_real tmp85;
ASSERT_ALIGNED_DOUBLE;
{
fftw_real tmp37;
fftw_real tmp40;
fftw_real tmp86;
fftw_real tmp87;
ASSERT_ALIGNED_DOUBLE;
tmp37 = tmp35 - tmp36;
tmp40 = tmp38 - tmp39;
tmp41 = tmp37 - tmp40;
tmp89 = tmp37 + tmp40;
tmp86 = tmp75 - tmp72;
tmp87 = tmp80 - tmp77;
tmp88 = tmp86 - tmp87;
tmp90 = tmp86 + tmp87;
}
{
fftw_real tmp46;
fftw_real tmp51;
fftw_real tmp55;
fftw_real tmp58;
ASSERT_ALIGNED_DOUBLE;
tmp46 = tmp42 - tmp45;
tmp51 = tmp47 - tmp50;
tmp52 = tmp46 - tmp51;
tmp60 = tmp46 + tmp51;
tmp55 = tmp53 - tmp54;
tmp58 = tmp56 - tmp57;
tmp59 = tmp55 + tmp58;
tmp85 = tmp55 - tmp58;
}
c_im(output[5 * ostride]) = tmp41 - tmp52;
c_im(output[11 * ostride]) = tmp41 + tmp52;
c_re(output[2 * ostride]) = tmp59 - tmp60;
c_re(output[8 * ostride]) = tmp59 + tmp60;
c_re(output[11 * ostride]) = tmp85 - tmp88;
c_re(output[5 * ostride]) = tmp85 + tmp88;
c_im(output[2 * ostride]) = tmp89 - tmp90;
c_im(output[8 * ostride]) = tmp89 + tmp90;
}
}
}
void zero_arr(int n, fftw_complex * a)
{
int i;
for (i = 0; i < n; ++i)
c_re(a[i]) = c_im(a[i]) = 0.0;
}
void fftw_hc2hc_backward_4(fftw_real *A, const fftw_complex *W,
int iostride, int m, int dist)
{
int i;
fftw_real *X;
fftw_real *Y;
X = A;
Y = A + (4 * iostride);
{
fftw_real tmp39;
fftw_real tmp42;
fftw_real tmp37;
fftw_real tmp40;
ASSERT_ALIGNED_DOUBLE;
{
fftw_real tmp38;
fftw_real tmp41;
fftw_real tmp35;
fftw_real tmp36;
ASSERT_ALIGNED_DOUBLE;
tmp38 = X[iostride];
tmp39 = K2_000000000 * tmp38;
tmp41 = Y[-iostride];
tmp42 = K2_000000000 * tmp41;
tmp35 = X[0];
tmp36 = X[2 * iostride];
tmp37 = tmp35 + tmp36;
tmp40 = tmp35 - tmp36;
}
X[2 * iostride] = tmp37 - tmp39;
X[0] = tmp37 + tmp39;
X[3 * iostride] = tmp40 + tmp42;
X[iostride] = tmp40 - tmp42;
}
X = X + dist;
Y = Y - dist;
for (i = 2; i < m; i = i + 2, X = X + dist, Y = Y - dist, W = W + 3) {
fftw_real tmp9;
fftw_real tmp28;
fftw_real tmp18;
fftw_real tmp25;
fftw_real tmp12;
fftw_real tmp24;
fftw_real tmp21;
fftw_real tmp29;
ASSERT_ALIGNED_DOUBLE;
{
fftw_real tmp7;
fftw_real tmp8;
fftw_real tmp16;
fftw_real tmp17;
ASSERT_ALIGNED_DOUBLE;
tmp7 = X[0];
tmp8 = Y[-2 * iostride];
tmp9 = tmp7 + tmp8;
tmp28 = tmp7 - tmp8;
tmp16 = Y[0];
tmp17 = X[2 * iostride];
tmp18 = tmp16 - tmp17;
tmp25 = tmp16 + tmp17;
}
{
fftw_real tmp10;
fftw_real tmp11;
fftw_real tmp19;
fftw_real tmp20;
ASSERT_ALIGNED_DOUBLE;
tmp10 = X[iostride];
tmp11 = Y[-3 * iostride];
tmp12 = tmp10 + tmp11;
tmp24 = tmp10 - tmp11;
tmp19 = Y[-iostride];
tmp20 = X[3 * iostride];
tmp21 = tmp19 - tmp20;
tmp29 = tmp19 + tmp20;
}
X[0] = tmp9 + tmp12;
{
fftw_real tmp14;
fftw_real tmp22;
fftw_real tmp13;
fftw_real tmp15;
ASSERT_ALIGNED_DOUBLE;
tmp14 = tmp9 - tmp12;
tmp22 = tmp18 - tmp21;
tmp13 = c_re(W[1]);
tmp15 = c_im(W[1]);
X[2 * iostride] = (tmp13 * tmp14) + (tmp15 * tmp22);
Y[-iostride] = (tmp13 * tmp22) - (tmp15 * tmp14);
}
Y[-3 * iostride] = tmp18 + tmp21;
{
fftw_real tmp26;
fftw_real tmp30;
fftw_real tmp23;
fftw_real tmp27;
ASSERT_ALIGNED_DOUBLE;
tmp26 = tmp24 + tmp25;
tmp30 = tmp28 - tmp29;
tmp23 = c_re(W[0]);
tmp27 = c_im(W[0]);
Y[-2 * iostride] = (tmp23 * tmp26) - (tmp27 * tmp30);
X[iostride] = (tmp27 * tmp26) + (tmp23 * tmp30);
}
{
fftw_real tmp32;
fftw_real tmp34;
fftw_real tmp31;
fftw_real tmp33;
ASSERT_ALIGNED_DOUBLE;
tmp32 = tmp25 - tmp24;
tmp34 = tmp28 + tmp29;
tmp31 = c_re(W[2]);
tmp33 = c_im(W[2]);
Y[0] = (tmp31 * tmp32) - (tmp33 * tmp34);
X[3 * iostride] = (tmp33 * tmp32) + (tmp31 * tmp34);
}
}
if (i == m) {
fftw_real tmp1;
fftw_real tmp2;
fftw_real tmp3;
fftw_real tmp4;
fftw_real tmp5;
fftw_real tmp6;
ASSERT_ALIGNED_DOUBLE;
tmp1 = X[0];
tmp2 = X[iostride];
tmp3 = tmp1 - tmp2;
tmp4 = Y[0];
tmp5 = Y[-iostride];
tmp6 = tmp4 + tmp5;
X[0] = K2_000000000 * (tmp1 + tmp2);
X[2 * iostride] = -(K2_000000000 * (tmp4 - tmp5));
X[iostride] = K1_414213562 * (tmp3 - tmp6);
X[3 * iostride] = -(K1_414213562 * (tmp3 + tmp6));
}
}
void testnd_in_place(int rank, int *n, fftw_direction dir,
fftwnd_plan validated_plan,
int alternate_api, int specific, int force_buffered)
{
int istride;
int N, dim, i;
fftw_complex *in1, *in2, *out2;
fftwnd_plan p;
int flags = measure_flag | wisdom_flag | FFTW_IN_PLACE;
if (coinflip())
flags |= FFTW_THREADSAFE;
if (force_buffered)
flags |= FFTWND_FORCE_BUFFERED;
N = 1;
for (dim = 0; dim < rank; ++dim)
N *= n[dim];
in1 = (fftw_complex *) fftw_malloc(N * MAX_STRIDE * sizeof(fftw_complex));
in2 = (fftw_complex *) fftw_malloc(N * sizeof(fftw_complex));
out2 = (fftw_complex *) fftw_malloc(N * sizeof(fftw_complex));
if (!specific) {
if (alternate_api && (rank == 2 || rank == 3)) {
if (rank == 2)
p = fftw2d_create_plan(n[0], n[1], dir, flags);
else
p = fftw3d_create_plan(n[0], n[1], n[2], dir, flags);
} else /* standard api */
p = fftwnd_create_plan(rank, n, dir, flags);
} else { /* specific plan creation */
if (alternate_api && (rank == 2 || rank == 3)) {
if (rank == 2)
p = fftw2d_create_plan_specific(n[0], n[1], dir, flags,
in1, 1,
(fftw_complex *) NULL, 1);
else
p = fftw3d_create_plan_specific(n[0], n[1], n[2], dir, flags,
in1, 1,
(fftw_complex *) NULL, 1);
} else /* standard api */
p = fftwnd_create_plan_specific(rank, n, dir, flags,
in1, 1,
(fftw_complex *) NULL, 1);
}
for (istride = 1; istride <= MAX_STRIDE; ++istride) {
/*
* generate random inputs */
for (i = 0; i < N; ++i) {
int j;
c_re(in2[i]) = DRAND();
c_im(in2[i]) = DRAND();
for (j = 0; j < istride; ++j) {
c_re(in1[i * istride + j]) = c_re(in2[i]);
c_im(in1[i * istride + j]) = c_im(in2[i]);
}
}
if (istride != 1 || istride != 1 || coinflip())
fftwnd_threads(nthreads, p, istride, in1, istride, 1,
(fftw_complex *) NULL, 1, 1);
else
fftwnd_threads_one(nthreads, p, in1, NULL);
fftwnd(validated_plan, 1, in2, 1, 1, out2, 1, 1);
for (i = 0; i < istride; ++i)
CHECK(compute_error_complex(in1 + i, istride, out2, 1, N) < TOLERANCE,
"testnd_in_place: wrong answer");
}
fftwnd_destroy_plan(p);
fftw_free(out2);
fftw_free(in2);
fftw_free(in1);
}
void fftwi_twiddle_16(fftw_complex *A, const fftw_complex *W, int iostride,
int m, int dist)
{
int i;
fftw_complex *inout;
inout = A;
for (i = m; i > 0; i = i - 1, inout = inout + dist, W = W + 15) {
fftw_real tmp7;
fftw_real tmp91;
fftw_real tmp180;
fftw_real tmp194;
fftw_real tmp18;
fftw_real tmp193;
fftw_real tmp94;
fftw_real tmp177;
fftw_real tmp77;
fftw_real tmp88;
fftw_real tmp161;
fftw_real tmp117;
fftw_real tmp141;
fftw_real tmp162;
fftw_real tmp163;
fftw_real tmp164;
fftw_real tmp112;
fftw_real tmp140;
fftw_real tmp30;
fftw_real tmp153;
fftw_real tmp100;
fftw_real tmp137;
fftw_real tmp41;
fftw_real tmp152;
fftw_real tmp105;
fftw_real tmp136;
fftw_real tmp54;
fftw_real tmp65;
fftw_real tmp156;
fftw_real tmp128;
fftw_real tmp144;
fftw_real tmp157;
fftw_real tmp158;
fftw_real tmp159;
fftw_real tmp123;
fftw_real tmp143;
ASSERT_ALIGNED_DOUBLE;
{
fftw_real tmp1;
fftw_real tmp179;
fftw_real tmp6;
fftw_real tmp178;
ASSERT_ALIGNED_DOUBLE;
tmp1 = c_re(inout[0]);
tmp179 = c_im(inout[0]);
{
fftw_real tmp3;
fftw_real tmp5;
fftw_real tmp2;
fftw_real tmp4;
ASSERT_ALIGNED_DOUBLE;
tmp3 = c_re(inout[8 * iostride]);
tmp5 = c_im(inout[8 * iostride]);
tmp2 = c_re(W[7]);
tmp4 = c_im(W[7]);
tmp6 = (tmp2 * tmp3) + (tmp4 * tmp5);
tmp178 = (tmp2 * tmp5) - (tmp4 * tmp3);
}
tmp7 = tmp1 + tmp6;
tmp91 = tmp1 - tmp6;
tmp180 = tmp178 + tmp179;
tmp194 = tmp179 - tmp178;
}
{
fftw_real tmp12;
fftw_real tmp92;
fftw_real tmp17;
fftw_real tmp93;
ASSERT_ALIGNED_DOUBLE;
{
fftw_real tmp9;
fftw_real tmp11;
fftw_real tmp8;
fftw_real tmp10;
ASSERT_ALIGNED_DOUBLE;
tmp9 = c_re(inout[4 * iostride]);
tmp11 = c_im(inout[4 * iostride]);
tmp8 = c_re(W[3]);
tmp10 = c_im(W[3]);
tmp12 = (tmp8 * tmp9) + (tmp10 * tmp11);
tmp92 = (tmp8 * tmp11) - (tmp10 * tmp9);
}
{
fftw_real tmp14;
fftw_real tmp16;
fftw_real tmp13;
fftw_real tmp15;
ASSERT_ALIGNED_DOUBLE;
tmp14 = c_re(inout[12 * iostride]);
tmp16 = c_im(inout[12 * iostride]);
tmp13 = c_re(W[11]);
tmp15 = c_im(W[11]);
tmp17 = (tmp13 * tmp14) + (tmp15 * tmp16);
tmp93 = (tmp13 * tmp16) - (tmp15 * tmp14);
}
tmp18 = tmp12 + tmp17;
tmp193 = tmp12 - tmp17;
tmp94 = tmp92 - tmp93;
tmp177 = tmp92 + tmp93;
}
{
fftw_real tmp71;
fftw_real tmp108;
fftw_real tmp87;
fftw_real tmp115;
fftw_real tmp76;
fftw_real tmp109;
fftw_real tmp82;
fftw_real tmp114;
ASSERT_ALIGNED_DOUBLE;
{
fftw_real tmp68;
fftw_real tmp70;
fftw_real tmp67;
fftw_real tmp69;
ASSERT_ALIGNED_DOUBLE;
tmp68 = c_re(inout[15 * iostride]);
tmp70 = c_im(inout[15 * iostride]);
tmp67 = c_re(W[14]);
tmp69 = c_im(W[14]);
tmp71 = (tmp67 * tmp68) + (tmp69 * tmp70);
tmp108 = (tmp67 * tmp70) - (tmp69 * tmp68);
}
{
fftw_real tmp84;
fftw_real tmp86;
fftw_real tmp83;
fftw_real tmp85;
ASSERT_ALIGNED_DOUBLE;
tmp84 = c_re(inout[11 * iostride]);
tmp86 = c_im(inout[11 * iostride]);
tmp83 = c_re(W[10]);
tmp85 = c_im(W[10]);
tmp87 = (tmp83 * tmp84) + (tmp85 * tmp86);
tmp115 = (tmp83 * tmp86) - (tmp85 * tmp84);
}
{
fftw_real tmp73;
fftw_real tmp75;
fftw_real tmp72;
fftw_real tmp74;
ASSERT_ALIGNED_DOUBLE;
tmp73 = c_re(inout[7 * iostride]);
tmp75 = c_im(inout[7 * iostride]);
tmp72 = c_re(W[6]);
tmp74 = c_im(W[6]);
tmp76 = (tmp72 * tmp73) + (tmp74 * tmp75);
tmp109 = (tmp72 * tmp75) - (tmp74 * tmp73);
}
{
fftw_real tmp79;
fftw_real tmp81;
fftw_real tmp78;
fftw_real tmp80;
ASSERT_ALIGNED_DOUBLE;
tmp79 = c_re(inout[3 * iostride]);
tmp81 = c_im(inout[3 * iostride]);
tmp78 = c_re(W[2]);
tmp80 = c_im(W[2]);
tmp82 = (tmp78 * tmp79) + (tmp80 * tmp81);
tmp114 = (tmp78 * tmp81) - (tmp80 * tmp79);
}
{
fftw_real tmp113;
fftw_real tmp116;
fftw_real tmp110;
fftw_real tmp111;
ASSERT_ALIGNED_DOUBLE;
tmp77 = tmp71 + tmp76;
tmp88 = tmp82 + tmp87;
tmp161 = tmp77 - tmp88;
tmp113 = tmp71 - tmp76;
tmp116 = tmp114 - tmp115;
tmp117 = tmp113 - tmp116;
tmp141 = tmp113 + tmp116;
tmp162 = tmp108 + tmp109;
tmp163 = tmp114 + tmp115;
tmp164 = tmp162 - tmp163;
tmp110 = tmp108 - tmp109;
tmp111 = tmp82 - tmp87;
tmp112 = tmp110 + tmp111;
tmp140 = tmp110 - tmp111;
}
}
{
fftw_real tmp24;
fftw_real tmp97;
fftw_real tmp29;
fftw_real tmp98;
fftw_real tmp96;
fftw_real tmp99;
ASSERT_ALIGNED_DOUBLE;
{
fftw_real tmp21;
fftw_real tmp23;
fftw_real tmp20;
fftw_real tmp22;
ASSERT_ALIGNED_DOUBLE;
tmp21 = c_re(inout[2 * iostride]);
tmp23 = c_im(inout[2 * iostride]);
tmp20 = c_re(W[1]);
tmp22 = c_im(W[1]);
tmp24 = (tmp20 * tmp21) + (tmp22 * tmp23);
tmp97 = (tmp20 * tmp23) - (tmp22 * tmp21);
}
{
fftw_real tmp26;
fftw_real tmp28;
fftw_real tmp25;
fftw_real tmp27;
ASSERT_ALIGNED_DOUBLE;
tmp26 = c_re(inout[10 * iostride]);
tmp28 = c_im(inout[10 * iostride]);
tmp25 = c_re(W[9]);
tmp27 = c_im(W[9]);
tmp29 = (tmp25 * tmp26) + (tmp27 * tmp28);
tmp98 = (tmp25 * tmp28) - (tmp27 * tmp26);
}
tmp30 = tmp24 + tmp29;
tmp153 = tmp97 + tmp98;
tmp96 = tmp24 - tmp29;
tmp99 = tmp97 - tmp98;
tmp100 = tmp96 - tmp99;
tmp137 = tmp96 + tmp99;
}
{
fftw_real tmp35;
fftw_real tmp102;
fftw_real tmp40;
fftw_real tmp103;
fftw_real tmp101;
fftw_real tmp104;
ASSERT_ALIGNED_DOUBLE;
{
fftw_real tmp32;
fftw_real tmp34;
fftw_real tmp31;
fftw_real tmp33;
ASSERT_ALIGNED_DOUBLE;
tmp32 = c_re(inout[14 * iostride]);
tmp34 = c_im(inout[14 * iostride]);
tmp31 = c_re(W[13]);
tmp33 = c_im(W[13]);
tmp35 = (tmp31 * tmp32) + (tmp33 * tmp34);
tmp102 = (tmp31 * tmp34) - (tmp33 * tmp32);
}
{
fftw_real tmp37;
fftw_real tmp39;
fftw_real tmp36;
fftw_real tmp38;
ASSERT_ALIGNED_DOUBLE;
tmp37 = c_re(inout[6 * iostride]);
tmp39 = c_im(inout[6 * iostride]);
tmp36 = c_re(W[5]);
tmp38 = c_im(W[5]);
tmp40 = (tmp36 * tmp37) + (tmp38 * tmp39);
tmp103 = (tmp36 * tmp39) - (tmp38 * tmp37);
}
tmp41 = tmp35 + tmp40;
tmp152 = tmp102 + tmp103;
tmp101 = tmp35 - tmp40;
tmp104 = tmp102 - tmp103;
tmp105 = tmp101 + tmp104;
tmp136 = tmp104 - tmp101;
}
{
fftw_real tmp48;
fftw_real tmp119;
fftw_real tmp64;
fftw_real tmp126;
fftw_real tmp53;
fftw_real tmp120;
fftw_real tmp59;
fftw_real tmp125;
ASSERT_ALIGNED_DOUBLE;
{
fftw_real tmp45;
fftw_real tmp47;
fftw_real tmp44;
fftw_real tmp46;
ASSERT_ALIGNED_DOUBLE;
tmp45 = c_re(inout[iostride]);
tmp47 = c_im(inout[iostride]);
tmp44 = c_re(W[0]);
tmp46 = c_im(W[0]);
tmp48 = (tmp44 * tmp45) + (tmp46 * tmp47);
tmp119 = (tmp44 * tmp47) - (tmp46 * tmp45);
}
{
fftw_real tmp61;
fftw_real tmp63;
fftw_real tmp60;
fftw_real tmp62;
ASSERT_ALIGNED_DOUBLE;
tmp61 = c_re(inout[13 * iostride]);
tmp63 = c_im(inout[13 * iostride]);
tmp60 = c_re(W[12]);
tmp62 = c_im(W[12]);
tmp64 = (tmp60 * tmp61) + (tmp62 * tmp63);
tmp126 = (tmp60 * tmp63) - (tmp62 * tmp61);
}
{
fftw_real tmp50;
fftw_real tmp52;
fftw_real tmp49;
fftw_real tmp51;
ASSERT_ALIGNED_DOUBLE;
tmp50 = c_re(inout[9 * iostride]);
tmp52 = c_im(inout[9 * iostride]);
tmp49 = c_re(W[8]);
tmp51 = c_im(W[8]);
tmp53 = (tmp49 * tmp50) + (tmp51 * tmp52);
tmp120 = (tmp49 * tmp52) - (tmp51 * tmp50);
}
{
fftw_real tmp56;
fftw_real tmp58;
fftw_real tmp55;
fftw_real tmp57;
ASSERT_ALIGNED_DOUBLE;
tmp56 = c_re(inout[5 * iostride]);
tmp58 = c_im(inout[5 * iostride]);
tmp55 = c_re(W[4]);
tmp57 = c_im(W[4]);
tmp59 = (tmp55 * tmp56) + (tmp57 * tmp58);
tmp125 = (tmp55 * tmp58) - (tmp57 * tmp56);
}
{
fftw_real tmp124;
fftw_real tmp127;
fftw_real tmp121;
fftw_real tmp122;
ASSERT_ALIGNED_DOUBLE;
tmp54 = tmp48 + tmp53;
tmp65 = tmp59 + tmp64;
tmp156 = tmp54 - tmp65;
tmp124 = tmp48 - tmp53;
tmp127 = tmp125 - tmp126;
tmp128 = tmp124 - tmp127;
tmp144 = tmp124 + tmp127;
tmp157 = tmp119 + tmp120;
tmp158 = tmp125 + tmp126;
tmp159 = tmp157 - tmp158;
tmp121 = tmp119 - tmp120;
tmp122 = tmp59 - tmp64;
tmp123 = tmp121 + tmp122;
tmp143 = tmp121 - tmp122;
}
}
{
fftw_real tmp107;
fftw_real tmp131;
fftw_real tmp196;
fftw_real tmp198;
fftw_real tmp130;
fftw_real tmp191;
fftw_real tmp134;
fftw_real tmp197;
ASSERT_ALIGNED_DOUBLE;
{
fftw_real tmp95;
fftw_real tmp106;
fftw_real tmp192;
fftw_real tmp195;
ASSERT_ALIGNED_DOUBLE;
tmp95 = tmp91 - tmp94;
tmp106 = K707106781 * (tmp100 + tmp105);
tmp107 = tmp95 - tmp106;
tmp131 = tmp95 + tmp106;
tmp192 = K707106781 * (tmp137 + tmp136);
tmp195 = tmp193 + tmp194;
tmp196 = tmp192 + tmp195;
tmp198 = tmp195 - tmp192;
}
{
fftw_real tmp118;
fftw_real tmp129;
fftw_real tmp132;
fftw_real tmp133;
ASSERT_ALIGNED_DOUBLE;
tmp118 = (K923879532 * tmp112) - (K382683432 * tmp117);
tmp129 = (K923879532 * tmp123) + (K382683432 * tmp128);
tmp130 = tmp118 - tmp129;
tmp191 = tmp129 + tmp118;
tmp132 = (K923879532 * tmp128) - (K382683432 * tmp123);
tmp133 = (K382683432 * tmp112) + (K923879532 * tmp117);
tmp134 = tmp132 + tmp133;
tmp197 = tmp132 - tmp133;
}
c_re(inout[13 * iostride]) = tmp107 - tmp130;
c_re(inout[5 * iostride]) = tmp107 + tmp130;
c_re(inout[9 * iostride]) = tmp131 - tmp134;
c_re(inout[iostride]) = tmp131 + tmp134;
c_im(inout[iostride]) = tmp191 + tmp196;
c_im(inout[9 * iostride]) = tmp196 - tmp191;
c_im(inout[5 * iostride]) = tmp197 + tmp198;
c_im(inout[13 * iostride]) = tmp198 - tmp197;
}
{
fftw_real tmp139;
fftw_real tmp147;
fftw_real tmp202;
fftw_real tmp204;
fftw_real tmp146;
fftw_real tmp199;
fftw_real tmp150;
fftw_real tmp203;
ASSERT_ALIGNED_DOUBLE;
{
fftw_real tmp135;
fftw_real tmp138;
fftw_real tmp200;
fftw_real tmp201;
ASSERT_ALIGNED_DOUBLE;
tmp135 = tmp91 + tmp94;
tmp138 = K707106781 * (tmp136 - tmp137);
tmp139 = tmp135 - tmp138;
tmp147 = tmp135 + tmp138;
tmp200 = K707106781 * (tmp100 - tmp105);
tmp201 = tmp194 - tmp193;
tmp202 = tmp200 + tmp201;
tmp204 = tmp201 - tmp200;
}
{
fftw_real tmp142;
fftw_real tmp145;
fftw_real tmp148;
fftw_real tmp149;
ASSERT_ALIGNED_DOUBLE;
tmp142 = (K382683432 * tmp140) - (K923879532 * tmp141);
tmp145 = (K382683432 * tmp143) + (K923879532 * tmp144);
tmp146 = tmp142 - tmp145;
tmp199 = tmp145 + tmp142;
tmp148 = (K382683432 * tmp144) - (K923879532 * tmp143);
tmp149 = (K923879532 * tmp140) + (K382683432 * tmp141);
tmp150 = tmp148 + tmp149;
tmp203 = tmp148 - tmp149;
}
c_re(inout[15 * iostride]) = tmp139 - tmp146;
c_re(inout[7 * iostride]) = tmp139 + tmp146;
c_re(inout[11 * iostride]) = tmp147 - tmp150;
c_re(inout[3 * iostride]) = tmp147 + tmp150;
c_im(inout[3 * iostride]) = tmp199 + tmp202;
c_im(inout[11 * iostride]) = tmp202 - tmp199;
c_im(inout[7 * iostride]) = tmp203 + tmp204;
c_im(inout[15 * iostride]) = tmp204 - tmp203;
}
{
fftw_real tmp155;
fftw_real tmp167;
fftw_real tmp188;
fftw_real tmp190;
fftw_real tmp166;
fftw_real tmp189;
fftw_real tmp170;
fftw_real tmp185;
ASSERT_ALIGNED_DOUBLE;
{
fftw_real tmp151;
fftw_real tmp154;
fftw_real tmp186;
fftw_real tmp187;
ASSERT_ALIGNED_DOUBLE;
tmp151 = tmp7 - tmp18;
tmp154 = tmp152 - tmp153;
tmp155 = tmp151 + tmp154;
tmp167 = tmp151 - tmp154;
tmp186 = tmp30 - tmp41;
tmp187 = tmp180 - tmp177;
tmp188 = tmp186 + tmp187;
tmp190 = tmp187 - tmp186;
}
{
fftw_real tmp160;
fftw_real tmp165;
fftw_real tmp168;
fftw_real tmp169;
ASSERT_ALIGNED_DOUBLE;
tmp160 = tmp156 - tmp159;
tmp165 = tmp161 + tmp164;
tmp166 = K707106781 * (tmp160 + tmp165);
tmp189 = K707106781 * (tmp160 - tmp165);
tmp168 = tmp164 - tmp161;
tmp169 = tmp156 + tmp159;
tmp170 = K707106781 * (tmp168 - tmp169);
tmp185 = K707106781 * (tmp169 + tmp168);
}
c_re(inout[10 * iostride]) = tmp155 - tmp166;
c_re(inout[2 * iostride]) = tmp155 + tmp166;
c_re(inout[14 * iostride]) = tmp167 - tmp170;
c_re(inout[6 * iostride]) = tmp167 + tmp170;
c_im(inout[2 * iostride]) = tmp185 + tmp188;
c_im(inout[10 * iostride]) = tmp188 - tmp185;
c_im(inout[6 * iostride]) = tmp189 + tmp190;
c_im(inout[14 * iostride]) = tmp190 - tmp189;
}
{
fftw_real tmp43;
fftw_real tmp171;
fftw_real tmp182;
fftw_real tmp184;
fftw_real tmp90;
fftw_real tmp183;
fftw_real tmp174;
fftw_real tmp175;
ASSERT_ALIGNED_DOUBLE;
{
fftw_real tmp19;
fftw_real tmp42;
fftw_real tmp176;
fftw_real tmp181;
ASSERT_ALIGNED_DOUBLE;
tmp19 = tmp7 + tmp18;
tmp42 = tmp30 + tmp41;
tmp43 = tmp19 + tmp42;
tmp171 = tmp19 - tmp42;
tmp176 = tmp153 + tmp152;
tmp181 = tmp177 + tmp180;
tmp182 = tmp176 + tmp181;
tmp184 = tmp181 - tmp176;
}
{
fftw_real tmp66;
fftw_real tmp89;
fftw_real tmp172;
fftw_real tmp173;
ASSERT_ALIGNED_DOUBLE;
tmp66 = tmp54 + tmp65;
tmp89 = tmp77 + tmp88;
tmp90 = tmp66 + tmp89;
tmp183 = tmp66 - tmp89;
tmp172 = tmp162 + tmp163;
tmp173 = tmp157 + tmp158;
tmp174 = tmp172 - tmp173;
tmp175 = tmp173 + tmp172;
}
c_re(inout[8 * iostride]) = tmp43 - tmp90;
c_re(inout[0]) = tmp43 + tmp90;
c_re(inout[12 * iostride]) = tmp171 - tmp174;
c_re(inout[4 * iostride]) = tmp171 + tmp174;
c_im(inout[0]) = tmp175 + tmp182;
c_im(inout[8 * iostride]) = tmp182 - tmp175;
c_im(inout[4 * iostride]) = tmp183 + tmp184;
c_im(inout[12 * iostride]) = tmp184 - tmp183;
}
}
}
void fftw_no_twiddle_10(const fftw_complex *input, fftw_complex *output, int istride, int ostride)
{
fftw_real tmp3;
fftw_real tmp19;
fftw_real tmp52;
fftw_real tmp76;
fftw_real tmp56;
fftw_real tmp57;
fftw_real tmp10;
fftw_real tmp17;
fftw_real tmp18;
fftw_real tmp74;
fftw_real tmp73;
fftw_real tmp22;
fftw_real tmp25;
fftw_real tmp26;
fftw_real tmp36;
fftw_real tmp43;
fftw_real tmp47;
fftw_real tmp48;
fftw_real tmp53;
fftw_real tmp66;
fftw_real tmp69;
fftw_real tmp77;
fftw_real tmp78;
fftw_real tmp79;
ASSERT_ALIGNED_DOUBLE;
{
fftw_real tmp1;
fftw_real tmp2;
fftw_real tmp50;
fftw_real tmp51;
ASSERT_ALIGNED_DOUBLE;
tmp1 = c_re(input[0]);
tmp2 = c_re(input[5 * istride]);
tmp3 = tmp1 - tmp2;
tmp19 = tmp1 + tmp2;
tmp50 = c_im(input[0]);
tmp51 = c_im(input[5 * istride]);
tmp52 = tmp50 - tmp51;
tmp76 = tmp50 + tmp51;
}
{
fftw_real tmp6;
fftw_real tmp20;
fftw_real tmp16;
fftw_real tmp24;
fftw_real tmp9;
fftw_real tmp21;
fftw_real tmp13;
fftw_real tmp23;
ASSERT_ALIGNED_DOUBLE;
{
fftw_real tmp4;
fftw_real tmp5;
fftw_real tmp14;
fftw_real tmp15;
ASSERT_ALIGNED_DOUBLE;
tmp4 = c_re(input[2 * istride]);
tmp5 = c_re(input[7 * istride]);
tmp6 = tmp4 - tmp5;
tmp20 = tmp4 + tmp5;
tmp14 = c_re(input[6 * istride]);
tmp15 = c_re(input[istride]);
tmp16 = tmp14 - tmp15;
tmp24 = tmp14 + tmp15;
}
{
fftw_real tmp7;
fftw_real tmp8;
fftw_real tmp11;
fftw_real tmp12;
ASSERT_ALIGNED_DOUBLE;
tmp7 = c_re(input[8 * istride]);
tmp8 = c_re(input[3 * istride]);
tmp9 = tmp7 - tmp8;
tmp21 = tmp7 + tmp8;
tmp11 = c_re(input[4 * istride]);
tmp12 = c_re(input[9 * istride]);
tmp13 = tmp11 - tmp12;
tmp23 = tmp11 + tmp12;
}
tmp56 = tmp6 - tmp9;
tmp57 = tmp13 - tmp16;
tmp10 = tmp6 + tmp9;
tmp17 = tmp13 + tmp16;
tmp18 = tmp10 + tmp17;
tmp74 = tmp20 - tmp21;
tmp73 = tmp23 - tmp24;
tmp22 = tmp20 + tmp21;
tmp25 = tmp23 + tmp24;
tmp26 = tmp22 + tmp25;
}
{
fftw_real tmp32;
fftw_real tmp67;
fftw_real tmp42;
fftw_real tmp65;
fftw_real tmp35;
fftw_real tmp68;
fftw_real tmp39;
fftw_real tmp64;
ASSERT_ALIGNED_DOUBLE;
{
fftw_real tmp30;
fftw_real tmp31;
fftw_real tmp40;
fftw_real tmp41;
ASSERT_ALIGNED_DOUBLE;
tmp30 = c_im(input[2 * istride]);
tmp31 = c_im(input[7 * istride]);
tmp32 = tmp30 - tmp31;
tmp67 = tmp30 + tmp31;
tmp40 = c_im(input[6 * istride]);
tmp41 = c_im(input[istride]);
tmp42 = tmp40 - tmp41;
tmp65 = tmp40 + tmp41;
}
{
fftw_real tmp33;
fftw_real tmp34;
fftw_real tmp37;
fftw_real tmp38;
ASSERT_ALIGNED_DOUBLE;
tmp33 = c_im(input[8 * istride]);
tmp34 = c_im(input[3 * istride]);
tmp35 = tmp33 - tmp34;
tmp68 = tmp33 + tmp34;
tmp37 = c_im(input[4 * istride]);
tmp38 = c_im(input[9 * istride]);
tmp39 = tmp37 - tmp38;
tmp64 = tmp37 + tmp38;
}
tmp36 = tmp32 - tmp35;
tmp43 = tmp39 - tmp42;
tmp47 = tmp32 + tmp35;
tmp48 = tmp39 + tmp42;
tmp53 = tmp47 + tmp48;
tmp66 = tmp64 - tmp65;
tmp69 = tmp67 - tmp68;
tmp77 = tmp67 + tmp68;
tmp78 = tmp64 + tmp65;
tmp79 = tmp77 + tmp78;
}
c_re(output[5 * ostride]) = tmp3 + tmp18;
{
fftw_real tmp44;
fftw_real tmp46;
fftw_real tmp29;
fftw_real tmp45;
fftw_real tmp27;
fftw_real tmp28;
ASSERT_ALIGNED_DOUBLE;
tmp44 = (K951056516 * tmp36) + (K587785252 * tmp43);
tmp46 = (K951056516 * tmp43) - (K587785252 * tmp36);
tmp27 = K559016994 * (tmp10 - tmp17);
tmp28 = tmp3 - (K250000000 * tmp18);
tmp29 = tmp27 + tmp28;
tmp45 = tmp28 - tmp27;
c_re(output[9 * ostride]) = tmp29 - tmp44;
c_re(output[ostride]) = tmp29 + tmp44;
c_re(output[7 * ostride]) = tmp45 - tmp46;
c_re(output[3 * ostride]) = tmp45 + tmp46;
}
c_re(output[0]) = tmp19 + tmp26;
{
fftw_real tmp70;
fftw_real tmp72;
fftw_real tmp63;
fftw_real tmp71;
fftw_real tmp61;
fftw_real tmp62;
ASSERT_ALIGNED_DOUBLE;
tmp70 = (K951056516 * tmp66) - (K587785252 * tmp69);
tmp72 = (K951056516 * tmp69) + (K587785252 * tmp66);
tmp61 = tmp19 - (K250000000 * tmp26);
tmp62 = K559016994 * (tmp22 - tmp25);
tmp63 = tmp61 - tmp62;
tmp71 = tmp62 + tmp61;
c_re(output[2 * ostride]) = tmp63 - tmp70;
c_re(output[8 * ostride]) = tmp63 + tmp70;
c_re(output[4 * ostride]) = tmp71 - tmp72;
c_re(output[6 * ostride]) = tmp71 + tmp72;
}
c_im(output[5 * ostride]) = tmp52 + tmp53;
{
fftw_real tmp58;
fftw_real tmp60;
fftw_real tmp55;
fftw_real tmp59;
fftw_real tmp49;
fftw_real tmp54;
ASSERT_ALIGNED_DOUBLE;
tmp58 = (K951056516 * tmp56) + (K587785252 * tmp57);
tmp60 = (K951056516 * tmp57) - (K587785252 * tmp56);
tmp49 = K559016994 * (tmp47 - tmp48);
tmp54 = tmp52 - (K250000000 * tmp53);
tmp55 = tmp49 + tmp54;
tmp59 = tmp54 - tmp49;
c_im(output[ostride]) = tmp55 - tmp58;
c_im(output[9 * ostride]) = tmp58 + tmp55;
c_im(output[3 * ostride]) = tmp59 - tmp60;
c_im(output[7 * ostride]) = tmp60 + tmp59;
}
c_im(output[0]) = tmp76 + tmp79;
{
fftw_real tmp75;
fftw_real tmp83;
fftw_real tmp82;
fftw_real tmp84;
fftw_real tmp80;
fftw_real tmp81;
ASSERT_ALIGNED_DOUBLE;
tmp75 = (K951056516 * tmp73) - (K587785252 * tmp74);
tmp83 = (K951056516 * tmp74) + (K587785252 * tmp73);
tmp80 = tmp76 - (K250000000 * tmp79);
tmp81 = K559016994 * (tmp77 - tmp78);
tmp82 = tmp80 - tmp81;
tmp84 = tmp81 + tmp80;
c_im(output[2 * ostride]) = tmp75 + tmp82;
c_im(output[8 * ostride]) = tmp82 - tmp75;
c_im(output[4 * ostride]) = tmp83 + tmp84;
c_im(output[6 * ostride]) = tmp84 - tmp83;
}
}
void fftwi_twiddle_7(fftw_complex *A, const fftw_complex *W, int iostride,
int m, int dist)
{
int i;
fftw_complex *inout;
inout = A;
for (i = m; i > 0; i = i - 1, inout = inout + dist, W = W + 6) {
fftw_real tmp1;
fftw_real tmp53;
fftw_real tmp12;
fftw_real tmp54;
fftw_real tmp38;
fftw_real tmp50;
fftw_real tmp23;
fftw_real tmp55;
fftw_real tmp44;
fftw_real tmp51;
fftw_real tmp34;
fftw_real tmp56;
fftw_real tmp41;
fftw_real tmp52;
ASSERT_ALIGNED_DOUBLE;
tmp1 = c_re(inout[0]);
tmp53 = c_im(inout[0]);
{
fftw_real tmp6;
fftw_real tmp37;
fftw_real tmp11;
fftw_real tmp36;
ASSERT_ALIGNED_DOUBLE;
{
fftw_real tmp3;
fftw_real tmp5;
fftw_real tmp2;
fftw_real tmp4;
ASSERT_ALIGNED_DOUBLE;
tmp3 = c_re(inout[iostride]);
tmp5 = c_im(inout[iostride]);
tmp2 = c_re(W[0]);
tmp4 = c_im(W[0]);
tmp6 = (tmp2 * tmp3) + (tmp4 * tmp5);
tmp37 = (tmp2 * tmp5) - (tmp4 * tmp3);
}
{
fftw_real tmp8;
fftw_real tmp10;
fftw_real tmp7;
fftw_real tmp9;
ASSERT_ALIGNED_DOUBLE;
tmp8 = c_re(inout[6 * iostride]);
tmp10 = c_im(inout[6 * iostride]);
tmp7 = c_re(W[5]);
tmp9 = c_im(W[5]);
tmp11 = (tmp7 * tmp8) + (tmp9 * tmp10);
tmp36 = (tmp7 * tmp10) - (tmp9 * tmp8);
}
tmp12 = tmp6 + tmp11;
tmp54 = tmp6 - tmp11;
tmp38 = tmp36 - tmp37;
tmp50 = tmp37 + tmp36;
}
{
fftw_real tmp17;
fftw_real tmp43;
fftw_real tmp22;
fftw_real tmp42;
ASSERT_ALIGNED_DOUBLE;
{
fftw_real tmp14;
fftw_real tmp16;
fftw_real tmp13;
fftw_real tmp15;
ASSERT_ALIGNED_DOUBLE;
tmp14 = c_re(inout[2 * iostride]);
tmp16 = c_im(inout[2 * iostride]);
tmp13 = c_re(W[1]);
tmp15 = c_im(W[1]);
tmp17 = (tmp13 * tmp14) + (tmp15 * tmp16);
tmp43 = (tmp13 * tmp16) - (tmp15 * tmp14);
}
{
fftw_real tmp19;
fftw_real tmp21;
fftw_real tmp18;
fftw_real tmp20;
ASSERT_ALIGNED_DOUBLE;
tmp19 = c_re(inout[5 * iostride]);
tmp21 = c_im(inout[5 * iostride]);
tmp18 = c_re(W[4]);
tmp20 = c_im(W[4]);
tmp22 = (tmp18 * tmp19) + (tmp20 * tmp21);
tmp42 = (tmp18 * tmp21) - (tmp20 * tmp19);
}
tmp23 = tmp17 + tmp22;
tmp55 = tmp17 - tmp22;
tmp44 = tmp42 - tmp43;
tmp51 = tmp43 + tmp42;
}
{
fftw_real tmp28;
fftw_real tmp40;
fftw_real tmp33;
fftw_real tmp39;
ASSERT_ALIGNED_DOUBLE;
{
fftw_real tmp25;
fftw_real tmp27;
fftw_real tmp24;
fftw_real tmp26;
ASSERT_ALIGNED_DOUBLE;
tmp25 = c_re(inout[3 * iostride]);
tmp27 = c_im(inout[3 * iostride]);
tmp24 = c_re(W[2]);
tmp26 = c_im(W[2]);
tmp28 = (tmp24 * tmp25) + (tmp26 * tmp27);
tmp40 = (tmp24 * tmp27) - (tmp26 * tmp25);
}
{
fftw_real tmp30;
fftw_real tmp32;
fftw_real tmp29;
fftw_real tmp31;
ASSERT_ALIGNED_DOUBLE;
tmp30 = c_re(inout[4 * iostride]);
tmp32 = c_im(inout[4 * iostride]);
tmp29 = c_re(W[3]);
tmp31 = c_im(W[3]);
tmp33 = (tmp29 * tmp30) + (tmp31 * tmp32);
tmp39 = (tmp29 * tmp32) - (tmp31 * tmp30);
}
tmp34 = tmp28 + tmp33;
tmp56 = tmp28 - tmp33;
tmp41 = tmp39 - tmp40;
tmp52 = tmp40 + tmp39;
}
{
fftw_real tmp47;
fftw_real tmp46;
fftw_real tmp59;
fftw_real tmp60;
ASSERT_ALIGNED_DOUBLE;
c_re(inout[0]) = tmp1 + tmp12 + tmp23 + tmp34;
tmp47 =
(K781831482 * tmp38) + (K974927912 * tmp44) +
(K433883739 * tmp41);
tmp46 =
tmp1 + (K623489801 * tmp12) - (K900968867 * tmp34) -
(K222520933 * tmp23);
c_re(inout[6 * iostride]) = tmp46 - tmp47;
c_re(inout[iostride]) = tmp46 + tmp47;
{
fftw_real tmp49;
fftw_real tmp48;
fftw_real tmp45;
fftw_real tmp35;
ASSERT_ALIGNED_DOUBLE;
tmp49 =
(K433883739 * tmp38) + (K974927912 * tmp41) -
(K781831482 * tmp44);
tmp48 =
tmp1 + (K623489801 * tmp23) -
(K222520933 * tmp34) - (K900968867 * tmp12);
c_re(inout[4 * iostride]) = tmp48 - tmp49;
c_re(inout[3 * iostride]) = tmp48 + tmp49;
tmp45 =
(K974927912 * tmp38) - (K781831482 * tmp41) -
(K433883739 * tmp44);
tmp35 =
tmp1 + (K623489801 * tmp34) -
(K900968867 * tmp23) - (K222520933 * tmp12);
c_re(inout[5 * iostride]) = tmp35 - tmp45;
c_re(inout[2 * iostride]) = tmp35 + tmp45;
}
c_im(inout[0]) = tmp50 + tmp51 + tmp52 + tmp53;
tmp59 =
(K974927912 * tmp54) - (K781831482 * tmp56) -
(K433883739 * tmp55);
tmp60 =
(K623489801 * tmp52) + tmp53 - (K900968867 * tmp51) -
(K222520933 * tmp50);
c_im(inout[2 * iostride]) = tmp59 + tmp60;
c_im(inout[5 * iostride]) = tmp60 - tmp59;
{
fftw_real tmp61;
fftw_real tmp62;
fftw_real tmp57;
fftw_real tmp58;
ASSERT_ALIGNED_DOUBLE;
tmp61 =
(K433883739 * tmp54) + (K974927912 * tmp56) -
(K781831482 * tmp55);
tmp62 =
(K623489801 * tmp51) + tmp53 -
(K222520933 * tmp52) - (K900968867 * tmp50);
c_im(inout[3 * iostride]) = tmp61 + tmp62;
c_im(inout[4 * iostride]) = tmp62 - tmp61;
tmp57 =
(K781831482 * tmp54) + (K974927912 * tmp55) +
(K433883739 * tmp56);
tmp58 =
(K623489801 * tmp50) + tmp53 -
(K900968867 * tmp52) - (K222520933 * tmp51);
c_im(inout[iostride]) = tmp57 + tmp58;
c_im(inout[6 * iostride]) = tmp58 - tmp57;
}
}
}
}
static void mkro01(C *a, int n) /* n should be be multiple of 4 */
{
c_re(a[0]) = c_im(a[0]) = 0.0;
mkre00(a, n/2);
mkro00(a, n);
}
void fftw_no_twiddle_6(const fftw_complex *input, fftw_complex *output, int istride, int ostride)
{
fftw_real tmp3;
fftw_real tmp11;
fftw_real tmp26;
fftw_real tmp33;
fftw_real tmp6;
fftw_real tmp12;
fftw_real tmp9;
fftw_real tmp13;
fftw_real tmp10;
fftw_real tmp14;
fftw_real tmp18;
fftw_real tmp30;
fftw_real tmp21;
fftw_real tmp31;
fftw_real tmp27;
fftw_real tmp34;
ASSERT_ALIGNED_DOUBLE;
{
fftw_real tmp1;
fftw_real tmp2;
fftw_real tmp24;
fftw_real tmp25;
ASSERT_ALIGNED_DOUBLE;
tmp1 = c_re(input[0]);
tmp2 = c_re(input[3 * istride]);
tmp3 = tmp1 - tmp2;
tmp11 = tmp1 + tmp2;
tmp24 = c_im(input[0]);
tmp25 = c_im(input[3 * istride]);
tmp26 = tmp24 - tmp25;
tmp33 = tmp24 + tmp25;
}
{
fftw_real tmp4;
fftw_real tmp5;
fftw_real tmp7;
fftw_real tmp8;
ASSERT_ALIGNED_DOUBLE;
tmp4 = c_re(input[2 * istride]);
tmp5 = c_re(input[5 * istride]);
tmp6 = tmp4 - tmp5;
tmp12 = tmp4 + tmp5;
tmp7 = c_re(input[4 * istride]);
tmp8 = c_re(input[istride]);
tmp9 = tmp7 - tmp8;
tmp13 = tmp7 + tmp8;
}
tmp10 = tmp6 + tmp9;
tmp14 = tmp12 + tmp13;
{
fftw_real tmp16;
fftw_real tmp17;
fftw_real tmp19;
fftw_real tmp20;
ASSERT_ALIGNED_DOUBLE;
tmp16 = c_im(input[2 * istride]);
tmp17 = c_im(input[5 * istride]);
tmp18 = tmp16 - tmp17;
tmp30 = tmp16 + tmp17;
tmp19 = c_im(input[4 * istride]);
tmp20 = c_im(input[istride]);
tmp21 = tmp19 - tmp20;
tmp31 = tmp19 + tmp20;
}
tmp27 = tmp18 + tmp21;
tmp34 = tmp30 + tmp31;
{
fftw_real tmp15;
fftw_real tmp22;
fftw_real tmp29;
fftw_real tmp32;
ASSERT_ALIGNED_DOUBLE;
c_re(output[3 * ostride]) = tmp3 + tmp10;
tmp15 = tmp3 - (K500000000 * tmp10);
tmp22 = K866025403 * (tmp18 - tmp21);
c_re(output[5 * ostride]) = tmp15 - tmp22;
c_re(output[ostride]) = tmp15 + tmp22;
c_re(output[0]) = tmp11 + tmp14;
tmp29 = tmp11 - (K500000000 * tmp14);
tmp32 = K866025403 * (tmp30 - tmp31);
c_re(output[2 * ostride]) = tmp29 - tmp32;
c_re(output[4 * ostride]) = tmp29 + tmp32;
}
{
fftw_real tmp23;
fftw_real tmp28;
fftw_real tmp35;
fftw_real tmp36;
ASSERT_ALIGNED_DOUBLE;
c_im(output[3 * ostride]) = tmp26 + tmp27;
tmp23 = K866025403 * (tmp9 - tmp6);
tmp28 = tmp26 - (K500000000 * tmp27);
c_im(output[ostride]) = tmp23 + tmp28;
c_im(output[5 * ostride]) = tmp28 - tmp23;
c_im(output[0]) = tmp33 + tmp34;
tmp35 = tmp33 - (K500000000 * tmp34);
tmp36 = K866025403 * (tmp13 - tmp12);
c_im(output[2 * ostride]) = tmp35 - tmp36;
c_im(output[4 * ostride]) = tmp36 + tmp35;
}
}
void fftw_twiddle_4(fftw_complex *A, const fftw_complex *W, int iostride,
int m, int dist)
{
int i;
fftw_complex *inout;
inout = A;
for (i = m; i > 0; i = i - 1, inout = inout + dist, W = W + 3) {
fftw_real tmp1;
fftw_real tmp25;
fftw_real tmp6;
fftw_real tmp24;
fftw_real tmp12;
fftw_real tmp20;
fftw_real tmp17;
fftw_real tmp21;
ASSERT_ALIGNED_DOUBLE;
tmp1 = c_re(inout[0]);
tmp25 = c_im(inout[0]);
{
fftw_real tmp3;
fftw_real tmp5;
fftw_real tmp2;
fftw_real tmp4;
ASSERT_ALIGNED_DOUBLE;
tmp3 = c_re(inout[2 * iostride]);
tmp5 = c_im(inout[2 * iostride]);
tmp2 = c_re(W[1]);
tmp4 = c_im(W[1]);
tmp6 = (tmp2 * tmp3) - (tmp4 * tmp5);
tmp24 = (tmp4 * tmp3) + (tmp2 * tmp5);
}
{
fftw_real tmp9;
fftw_real tmp11;
fftw_real tmp8;
fftw_real tmp10;
ASSERT_ALIGNED_DOUBLE;
tmp9 = c_re(inout[iostride]);
tmp11 = c_im(inout[iostride]);
tmp8 = c_re(W[0]);
tmp10 = c_im(W[0]);
tmp12 = (tmp8 * tmp9) - (tmp10 * tmp11);
tmp20 = (tmp10 * tmp9) + (tmp8 * tmp11);
}
{
fftw_real tmp14;
fftw_real tmp16;
fftw_real tmp13;
fftw_real tmp15;
ASSERT_ALIGNED_DOUBLE;
tmp14 = c_re(inout[3 * iostride]);
tmp16 = c_im(inout[3 * iostride]);
tmp13 = c_re(W[2]);
tmp15 = c_im(W[2]);
tmp17 = (tmp13 * tmp14) - (tmp15 * tmp16);
tmp21 = (tmp15 * tmp14) + (tmp13 * tmp16);
}
{
fftw_real tmp7;
fftw_real tmp18;
fftw_real tmp27;
fftw_real tmp28;
ASSERT_ALIGNED_DOUBLE;
tmp7 = tmp1 + tmp6;
tmp18 = tmp12 + tmp17;
c_re(inout[2 * iostride]) = tmp7 - tmp18;
c_re(inout[0]) = tmp7 + tmp18;
tmp27 = tmp25 - tmp24;
tmp28 = tmp12 - tmp17;
c_im(inout[iostride]) = tmp27 - tmp28;
c_im(inout[3 * iostride]) = tmp28 + tmp27;
}
{
fftw_real tmp23;
fftw_real tmp26;
fftw_real tmp19;
fftw_real tmp22;
ASSERT_ALIGNED_DOUBLE;
tmp23 = tmp20 + tmp21;
tmp26 = tmp24 + tmp25;
c_im(inout[0]) = tmp23 + tmp26;
c_im(inout[2 * iostride]) = tmp26 - tmp23;
tmp19 = tmp1 - tmp6;
tmp22 = tmp20 - tmp21;
c_re(inout[3 * iostride]) = tmp19 - tmp22;
c_re(inout[iostride]) = tmp19 + tmp22;
}
}
}