diff options
Diffstat (limited to 'src/fftw3/rdft/codelets/hc2r')
48 files changed, 13003 insertions, 0 deletions
diff --git a/src/fftw3/rdft/codelets/hc2r/hb_10.c b/src/fftw3/rdft/codelets/hc2r/hb_10.c new file mode 100644 index 0000000..3d96502 --- /dev/null +++ b/src/fftw3/rdft/codelets/hc2r/hb_10.c @@ -0,0 +1,265 @@ +/* + * Copyright (c) 2003 Matteo Frigo + * Copyright (c) 2003 Massachusetts Institute of Technology + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +/* This file was automatically generated --- DO NOT EDIT */ +/* Generated on Sat Jul 5 22:11:33 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_hc2hc -compact -variables 4 -sign 1 -n 10 -dif -name hb_10 -include hb.h */ + +/* + * This function contains 102 FP additions, 60 FP multiplications, + * (or, 72 additions, 30 multiplications, 30 fused multiply/add), + * 39 stack variables, and 40 memory accesses + */ +/* + * Generator Id's : + * $Id: hb_10.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: hb_10.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: hb_10.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + */ + +#include "hb.h" + +static const R *hb_10(R *rio, R *iio, const R *W, stride ios, int m, int dist) +{ + DK(KP250000000, +0.250000000000000000000000000000000000000000000); + DK(KP951056516, +0.951056516295153572116439333379382143405698634); + DK(KP587785252, +0.587785252292473129168705954639072768597652438); + DK(KP559016994, +0.559016994374947424102293417182819058860154590); + int i; + for (i = m - 2; i > 0; i = i - 2, rio = rio + dist, iio = iio - dist, W = W + 18) { + E T3, Tk, Tw, T1w, TO, TP, T1E, T1D, Tr, TX, Ti, T1l, TZ, T10, T1s; + E T1p, T1z, T1B, TL, TS; + { + E T1, T2, Tu, Tv; + T1 = rio[0]; + T2 = iio[-WS(ios, 5)]; + T3 = T1 + T2; + Tk = T1 - T2; + Tu = iio[0]; + Tv = rio[WS(ios, 5)]; + Tw = Tu + Tv; + T1w = Tu - Tv; + } + { + E T6, Tl, Tg, Tp, T9, Tm, Td, To; + { + E T4, T5, Te, Tf; + T4 = rio[WS(ios, 2)]; + T5 = iio[-WS(ios, 7)]; + T6 = T4 + T5; + Tl = T4 - T5; + Te = iio[-WS(ios, 6)]; + Tf = rio[WS(ios, 1)]; + Tg = Te + Tf; + Tp = Te - Tf; + } + { + E T7, T8, Tb, Tc; + T7 = iio[-WS(ios, 8)]; + T8 = rio[WS(ios, 3)]; + T9 = T7 + T8; + Tm = T7 - T8; + Tb = rio[WS(ios, 4)]; + Tc = iio[-WS(ios, 9)]; + Td = Tb + Tc; + To = Tb - Tc; + } + TO = Tl - Tm; + TP = To - Tp; + T1E = Td - Tg; + T1D = T6 - T9; + { + E Tn, Tq, Ta, Th; + Tn = Tl + Tm; + Tq = To + Tp; + Tr = Tn + Tq; + TX = KP559016994 * (Tn - Tq); + Ta = T6 + T9; + Th = Td + Tg; + Ti = Ta + Th; + T1l = KP559016994 * (Ta - Th); + } + } + { + E Tz, T1n, TJ, T1r, TC, T1o, TG, T1q; + { + E Tx, Ty, TH, TI; + Tx = iio[-WS(ios, 2)]; + Ty = rio[WS(ios, 7)]; + Tz = Tx + Ty; + T1n = Tx - Ty; + TH = rio[WS(ios, 6)]; + TI = iio[-WS(ios, 1)]; + TJ = TH + TI; + T1r = TI - TH; + } + { + E TA, TB, TE, TF; + TA = rio[WS(ios, 8)]; + TB = iio[-WS(ios, 3)]; + TC = TA + TB; + T1o = TB - TA; + TE = iio[-WS(ios, 4)]; + TF = rio[WS(ios, 9)]; + TG = TE + TF; + T1q = TE - TF; + } + TZ = Tz + TC; + T10 = TG + TJ; + T1s = T1q - T1r; + T1p = T1n - T1o; + { + E T1x, T1y, TD, TK; + T1x = T1n + T1o; + T1y = T1q + T1r; + T1z = T1x + T1y; + T1B = KP559016994 * (T1x - T1y); + TD = Tz - TC; + TK = TG - TJ; + TL = TD + TK; + TS = KP559016994 * (TD - TK); + } + } + rio[0] = T3 + Ti; + iio[-WS(ios, 9)] = T1w + T1z; + { + E Ts, TM, Tj, Tt; + Ts = Tk + Tr; + TM = Tw + TL; + Tj = W[8]; + Tt = W[9]; + rio[WS(ios, 5)] = FNMS(Tt, TM, Tj * Ts); + iio[-WS(ios, 4)] = FMA(Tt, Ts, Tj * TM); + } + { + E T1t, T1F, T1Q, T1N, T1C, T1R, T1m, T1M, T1A, T1k; + T1t = FNMS(KP951056516, T1s, KP587785252 * T1p); + T1F = FNMS(KP951056516, T1E, KP587785252 * T1D); + T1Q = FMA(KP951056516, T1D, KP587785252 * T1E); + T1N = FMA(KP951056516, T1p, KP587785252 * T1s); + T1A = FNMS(KP250000000, T1z, T1w); + T1C = T1A - T1B; + T1R = T1B + T1A; + T1k = FNMS(KP250000000, Ti, T3); + T1m = T1k - T1l; + T1M = T1l + T1k; + { + E T1u, T1G, T1j, T1v; + T1u = T1m + T1t; + T1G = T1C - T1F; + T1j = W[14]; + T1v = W[15]; + rio[WS(ios, 8)] = FNMS(T1v, T1G, T1j * T1u); + iio[-WS(ios, 1)] = FMA(T1v, T1u, T1j * T1G); + } + { + E T1U, T1W, T1T, T1V; + T1U = T1M + T1N; + T1W = T1R - T1Q; + T1T = W[6]; + T1V = W[7]; + rio[WS(ios, 4)] = FNMS(T1V, T1W, T1T * T1U); + iio[-WS(ios, 5)] = FMA(T1V, T1U, T1T * T1W); + } + { + E T1I, T1K, T1H, T1J; + T1I = T1m - T1t; + T1K = T1F + T1C; + T1H = W[2]; + T1J = W[3]; + rio[WS(ios, 2)] = FNMS(T1J, T1K, T1H * T1I); + iio[-WS(ios, 7)] = FMA(T1J, T1I, T1H * T1K); + } + { + E T1O, T1S, T1L, T1P; + T1O = T1M - T1N; + T1S = T1Q + T1R; + T1L = W[10]; + T1P = W[11]; + rio[WS(ios, 6)] = FNMS(T1P, T1S, T1L * T1O); + iio[-WS(ios, 3)] = FMA(T1P, T1O, T1L * T1S); + } + } + { + E TQ, T11, T1c, T19, TY, T18, TT, T1d, TW, TR; + TQ = FNMS(KP951056516, TP, KP587785252 * TO); + T11 = FNMS(KP951056516, T10, KP587785252 * TZ); + T1c = FMA(KP951056516, TO, KP587785252 * TP); + T19 = FMA(KP951056516, TZ, KP587785252 * T10); + TW = FNMS(KP250000000, Tr, Tk); + TY = TW - TX; + T18 = TX + TW; + TR = FNMS(KP250000000, TL, Tw); + TT = TR - TS; + T1d = TS + TR; + { + E TU, T12, TN, TV; + TU = TQ + TT; + T12 = TY - T11; + TN = W[12]; + TV = W[13]; + iio[-WS(ios, 2)] = FMA(TN, TU, TV * T12); + rio[WS(ios, 7)] = FNMS(TV, TU, TN * T12); + } + { + E T1g, T1i, T1f, T1h; + T1g = T1d - T1c; + T1i = T18 + T19; + T1f = W[16]; + T1h = W[17]; + iio[0] = FMA(T1f, T1g, T1h * T1i); + rio[WS(ios, 9)] = FNMS(T1h, T1g, T1f * T1i); + } + { + E T14, T16, T13, T15; + T14 = TY + T11; + T16 = TT - TQ; + T13 = W[4]; + T15 = W[5]; + rio[WS(ios, 3)] = FNMS(T15, T16, T13 * T14); + iio[-WS(ios, 6)] = FMA(T13, T16, T15 * T14); + } + { + E T1a, T1e, T17, T1b; + T1a = T18 - T19; + T1e = T1c + T1d; + T17 = W[0]; + T1b = W[1]; + rio[WS(ios, 1)] = FNMS(T1b, T1e, T17 * T1a); + iio[-WS(ios, 8)] = FMA(T17, T1e, T1b * T1a); + } + } + } + return W; +} + +static const tw_instr twinstr[] = { + {TW_FULL, 0, 10}, + {TW_NEXT, 1, 0} +}; + +static const hc2hc_desc desc = { 10, "hb_10", twinstr, {72, 30, 30, 0}, &GENUS, 0, 0, 0 }; + +void X(codelet_hb_10) (planner *p) { + X(khc2hc_dif_register) (p, hb_10, &desc); +} diff --git a/src/fftw3/rdft/codelets/hc2r/hb_12.c b/src/fftw3/rdft/codelets/hc2r/hb_12.c new file mode 100644 index 0000000..55e7db0 --- /dev/null +++ b/src/fftw3/rdft/codelets/hc2r/hb_12.c @@ -0,0 +1,299 @@ +/* + * Copyright (c) 2003 Matteo Frigo + * Copyright (c) 2003 Massachusetts Institute of Technology + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +/* This file was automatically generated --- DO NOT EDIT */ +/* Generated on Sat Jul 5 22:11:36 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_hc2hc -compact -variables 4 -sign 1 -n 12 -dif -name hb_12 -include hb.h */ + +/* + * This function contains 118 FP additions, 60 FP multiplications, + * (or, 88 additions, 30 multiplications, 30 fused multiply/add), + * 39 stack variables, and 48 memory accesses + */ +/* + * Generator Id's : + * $Id: hb_12.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: hb_12.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: hb_12.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + */ + +#include "hb.h" + +static const R *hb_12(R *rio, R *iio, const R *W, stride ios, int m, int dist) +{ + DK(KP500000000, +0.500000000000000000000000000000000000000000000); + DK(KP866025403, +0.866025403784438646763723170752936183471402627); + int i; + for (i = m - 2; i > 0; i = i - 2, rio = rio + dist, iio = iio - dist, W = W + 22) { + E T5, Tt, T12, T1M, T1i, T1U, Tl, TM, T1c, T1Y, T1s, T1Q, Ta, Ty, T15; + E T1N, T1l, T1V, Tg, TH, T19, T1X, T1p, T1P; + { + E T1, Tp, T4, T1g, Ts, T11, T10, T1h; + T1 = rio[0]; + Tp = iio[0]; + { + E T2, T3, Tq, Tr; + T2 = rio[WS(ios, 4)]; + T3 = iio[-WS(ios, 8)]; + T4 = T2 + T3; + T1g = KP866025403 * (T2 - T3); + Tq = rio[WS(ios, 8)]; + Tr = iio[-WS(ios, 4)]; + Ts = Tq - Tr; + T11 = KP866025403 * (Tq + Tr); + } + T5 = T1 + T4; + Tt = Tp - Ts; + T10 = FNMS(KP500000000, T4, T1); + T12 = T10 - T11; + T1M = T10 + T11; + T1h = FMA(KP500000000, Ts, Tp); + T1i = T1g + T1h; + T1U = T1h - T1g; + } + { + E Th, TL, Tk, T1a, TK, T1r, T1b, T1q; + Th = iio[-WS(ios, 9)]; + TL = rio[WS(ios, 9)]; + { + E Ti, Tj, TI, TJ; + Ti = rio[WS(ios, 1)]; + Tj = rio[WS(ios, 5)]; + Tk = Ti + Tj; + T1a = KP866025403 * (Ti - Tj); + TI = iio[-WS(ios, 5)]; + TJ = iio[-WS(ios, 1)]; + TK = TI + TJ; + T1r = KP866025403 * (TI - TJ); + } + Tl = Th + Tk; + TM = TK - TL; + T1b = FMA(KP500000000, TK, TL); + T1c = T1a - T1b; + T1Y = T1a + T1b; + T1q = FNMS(KP500000000, Tk, Th); + T1s = T1q + T1r; + T1Q = T1q - T1r; + } + { + E T6, Tx, T9, T1j, Tw, T14, T13, T1k; + T6 = iio[-WS(ios, 6)]; + Tx = rio[WS(ios, 6)]; + { + E T7, T8, Tu, Tv; + T7 = iio[-WS(ios, 10)]; + T8 = rio[WS(ios, 2)]; + T9 = T7 + T8; + T1j = KP866025403 * (T7 - T8); + Tu = rio[WS(ios, 10)]; + Tv = iio[-WS(ios, 2)]; + Tw = Tu - Tv; + T14 = KP866025403 * (Tu + Tv); + } + Ta = T6 + T9; + Ty = Tw + Tx; + T13 = FNMS(KP500000000, T9, T6); + T15 = T13 + T14; + T1N = T13 - T14; + T1k = FMS(KP500000000, Tw, Tx); + T1l = T1j + T1k; + T1V = T1k - T1j; + } + { + E Tc, TD, Tf, T17, TG, T1o, T18, T1n; + Tc = rio[WS(ios, 3)]; + TD = iio[-WS(ios, 3)]; + { + E Td, Te, TE, TF; + Td = iio[-WS(ios, 7)]; + Te = iio[-WS(ios, 11)]; + Tf = Td + Te; + T17 = KP866025403 * (Td - Te); + TE = rio[WS(ios, 7)]; + TF = rio[WS(ios, 11)]; + TG = TE + TF; + T1o = KP866025403 * (TE - TF); + } + Tg = Tc + Tf; + TH = TD - TG; + T18 = FMA(KP500000000, TG, TD); + T19 = T17 + T18; + T1X = T18 - T17; + T1n = FNMS(KP500000000, Tf, Tc); + T1p = T1n + T1o; + T1P = T1n - T1o; + } + { + E Tb, Tm, TU, TW, TX, TY, TT, TV; + Tb = T5 + Ta; + Tm = Tg + Tl; + TU = Tb - Tm; + TW = Tt - Ty; + TX = TH + TM; + TY = TW - TX; + rio[0] = Tb + Tm; + iio[-WS(ios, 11)] = TW + TX; + TT = W[10]; + TV = W[11]; + rio[WS(ios, 6)] = FNMS(TV, TY, TT * TU); + iio[-WS(ios, 5)] = FMA(TV, TU, TT * TY); + } + { + E T28, T2g, T2c, T2e; + { + E T26, T27, T2a, T2b; + T26 = T1M - T1N; + T27 = T1X + T1Y; + T28 = T26 - T27; + T2g = T26 + T27; + T2a = T1U - T1V; + T2b = T1P - T1Q; + T2c = T2a + T2b; + T2e = T2a - T2b; + } + { + E T25, T29, T2d, T2f; + T25 = W[8]; + T29 = W[9]; + rio[WS(ios, 5)] = FNMS(T29, T2c, T25 * T28); + iio[-WS(ios, 6)] = FMA(T25, T2c, T29 * T28); + T2d = W[20]; + T2f = W[21]; + iio[0] = FMA(T2d, T2e, T2f * T2g); + rio[WS(ios, 11)] = FNMS(T2f, T2e, T2d * T2g); + } + } + { + E TA, TS, TO, TQ; + { + E To, Tz, TC, TN; + To = Tg - Tl; + Tz = Tt + Ty; + TA = To + Tz; + TS = Tz - To; + TC = T5 - Ta; + TN = TH - TM; + TO = TC - TN; + TQ = TC + TN; + } + { + E Tn, TB, TP, TR; + Tn = W[16]; + TB = W[17]; + iio[-WS(ios, 2)] = FMA(Tn, TA, TB * TO); + rio[WS(ios, 9)] = FNMS(TB, TA, Tn * TO); + TP = W[4]; + TR = W[5]; + rio[WS(ios, 3)] = FNMS(TR, TS, TP * TQ); + iio[-WS(ios, 8)] = FMA(TP, TS, TR * TQ); + } + } + { + E T1S, T22, T20, T24; + { + E T1O, T1R, T1W, T1Z; + T1O = T1M + T1N; + T1R = T1P + T1Q; + T1S = T1O - T1R; + T22 = T1O + T1R; + T1W = T1U + T1V; + T1Z = T1X - T1Y; + T20 = T1W - T1Z; + T24 = T1W + T1Z; + } + { + E T1L, T1T, T21, T23; + T1L = W[2]; + T1T = W[3]; + rio[WS(ios, 2)] = FNMS(T1T, T20, T1L * T1S); + iio[-WS(ios, 9)] = FMA(T1T, T1S, T1L * T20); + T21 = W[14]; + T23 = W[15]; + rio[WS(ios, 8)] = FNMS(T23, T24, T21 * T22); + iio[-WS(ios, 3)] = FMA(T23, T22, T21 * T24); + } + } + { + E T1C, T1I, T1G, T1K; + { + E T1A, T1B, T1E, T1F; + T1A = T12 + T15; + T1B = T1p + T1s; + T1C = T1A - T1B; + T1I = T1A + T1B; + T1E = T1i + T1l; + T1F = T19 + T1c; + T1G = T1E - T1F; + T1K = T1E + T1F; + } + { + E T1z, T1D, T1H, T1J; + T1z = W[18]; + T1D = W[19]; + rio[WS(ios, 10)] = FNMS(T1D, T1G, T1z * T1C); + iio[-WS(ios, 1)] = FMA(T1D, T1C, T1z * T1G); + T1H = W[6]; + T1J = W[7]; + rio[WS(ios, 4)] = FNMS(T1J, T1K, T1H * T1I); + iio[-WS(ios, 7)] = FMA(T1J, T1I, T1H * T1K); + } + } + { + E T1e, T1y, T1u, T1w; + { + E T16, T1d, T1m, T1t; + T16 = T12 - T15; + T1d = T19 - T1c; + T1e = T16 - T1d; + T1y = T16 + T1d; + T1m = T1i - T1l; + T1t = T1p - T1s; + T1u = T1m + T1t; + T1w = T1m - T1t; + } + { + E TZ, T1f, T1v, T1x; + TZ = W[0]; + T1f = W[1]; + rio[WS(ios, 1)] = FNMS(T1f, T1u, TZ * T1e); + iio[-WS(ios, 10)] = FMA(TZ, T1u, T1f * T1e); + T1v = W[12]; + T1x = W[13]; + iio[-WS(ios, 4)] = FMA(T1v, T1w, T1x * T1y); + rio[WS(ios, 7)] = FNMS(T1x, T1w, T1v * T1y); + } + } + } + return W; +} + +static const tw_instr twinstr[] = { + {TW_FULL, 0, 12}, + {TW_NEXT, 1, 0} +}; + +static const hc2hc_desc desc = { 12, "hb_12", twinstr, {88, 30, 30, 0}, &GENUS, 0, 0, 0 }; + +void X(codelet_hb_12) (planner *p) { + X(khc2hc_dif_register) (p, hb_12, &desc); +} diff --git a/src/fftw3/rdft/codelets/hc2r/hb_15.c b/src/fftw3/rdft/codelets/hc2r/hb_15.c new file mode 100644 index 0000000..8531f81 --- /dev/null +++ b/src/fftw3/rdft/codelets/hc2r/hb_15.c @@ -0,0 +1,404 @@ +/* + * Copyright (c) 2003 Matteo Frigo + * Copyright (c) 2003 Massachusetts Institute of Technology + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +/* This file was automatically generated --- DO NOT EDIT */ +/* Generated on Sat Jul 5 22:11:36 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_hc2hc -compact -variables 4 -sign 1 -n 15 -dif -name hb_15 -include hb.h */ + +/* + * This function contains 184 FP additions, 112 FP multiplications, + * (or, 128 additions, 56 multiplications, 56 fused multiply/add), + * 75 stack variables, and 60 memory accesses + */ +/* + * Generator Id's : + * $Id: hb_15.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: hb_15.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: hb_15.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + */ + +#include "hb.h" + +static const R *hb_15(R *rio, R *iio, const R *W, stride ios, int m, int dist) +{ + DK(KP250000000, +0.250000000000000000000000000000000000000000000); + DK(KP559016994, +0.559016994374947424102293417182819058860154590); + DK(KP587785252, +0.587785252292473129168705954639072768597652438); + DK(KP951056516, +0.951056516295153572116439333379382143405698634); + DK(KP500000000, +0.500000000000000000000000000000000000000000000); + DK(KP866025403, +0.866025403784438646763723170752936183471402627); + int i; + for (i = m - 2; i > 0; i = i - 2, rio = rio + dist, iio = iio - dist, W = W + 28) { + E T5, T2N, TV, T25, T1v, T2o, T2W, T38, T37, T2X, T2Q, T2T, T2U, Tg, Tr; + E Ts, Ty, TD, TE, T2c, T2d, T2m, TJ, TO, TP, T1Y, T1Z, T20, T1e, T1j; + E T1p, T13, T18, T1o, T29, T2a, T2l, T21, T22, T23; + { + E T1, T1r, T4, T1u, TU, T1s, TR, T1t; + T1 = rio[0]; + T1r = iio[0]; + { + E T2, T3, TS, TT; + T2 = rio[WS(ios, 5)]; + T3 = iio[-WS(ios, 10)]; + T4 = T2 + T3; + T1u = KP866025403 * (T2 - T3); + TS = rio[WS(ios, 10)]; + TT = iio[-WS(ios, 5)]; + TU = KP866025403 * (TS + TT); + T1s = TS - TT; + } + T5 = T1 + T4; + T2N = T1r - T1s; + TR = FNMS(KP500000000, T4, T1); + TV = TR + TU; + T25 = TR - TU; + T1t = FMA(KP500000000, T1s, T1r); + T1v = T1t - T1u; + T2o = T1u + T1t; + } + { + E Ta, T12, Tu, Tx, T2O, T11, Tf, T14, Tz, TC, T2P, T17, Tl, T1d, TF; + E TI, T2R, T1c, Tq, T1i, TK, TN, T2S, T1h; + { + E T6, T7, T8, T9; + T6 = rio[WS(ios, 3)]; + T7 = iio[-WS(ios, 8)]; + T8 = iio[-WS(ios, 13)]; + T9 = T7 + T8; + Ta = T6 + T9; + T12 = KP866025403 * (T7 - T8); + Tu = FNMS(KP500000000, T9, T6); + } + { + E TZ, Tv, Tw, T10; + TZ = iio[-WS(ios, 3)]; + Tv = rio[WS(ios, 8)]; + Tw = rio[WS(ios, 13)]; + T10 = Tv + Tw; + Tx = KP866025403 * (Tv - Tw); + T2O = TZ - T10; + T11 = FMA(KP500000000, T10, TZ); + } + { + E Tb, Tc, Td, Te; + Tb = iio[-WS(ios, 12)]; + Tc = rio[WS(ios, 2)]; + Td = rio[WS(ios, 7)]; + Te = Tc + Td; + Tf = Tb + Te; + T14 = KP866025403 * (Tc - Td); + Tz = FNMS(KP500000000, Te, Tb); + } + { + E T15, TA, TB, T16; + T15 = rio[WS(ios, 12)]; + TA = iio[-WS(ios, 7)]; + TB = iio[-WS(ios, 2)]; + T16 = TB + TA; + TC = KP866025403 * (TA - TB); + T2P = T16 - T15; + T17 = FMA(KP500000000, T16, T15); + } + { + E Th, Ti, Tj, Tk; + Th = rio[WS(ios, 6)]; + Ti = iio[-WS(ios, 11)]; + Tj = rio[WS(ios, 1)]; + Tk = Ti + Tj; + Tl = Th + Tk; + T1d = KP866025403 * (Ti - Tj); + TF = FNMS(KP500000000, Tk, Th); + } + { + E T1a, TG, TH, T1b; + T1a = iio[-WS(ios, 6)]; + TG = rio[WS(ios, 11)]; + TH = iio[-WS(ios, 1)]; + T1b = TG - TH; + TI = KP866025403 * (TG + TH); + T2R = T1a - T1b; + T1c = FMA(KP500000000, T1b, T1a); + } + { + E Tm, Tn, To, Tp; + Tm = iio[-WS(ios, 9)]; + Tn = iio[-WS(ios, 14)]; + To = rio[WS(ios, 4)]; + Tp = Tn + To; + Tq = Tm + Tp; + T1i = KP866025403 * (Tn - To); + TK = FNMS(KP500000000, Tp, Tm); + } + { + E T1g, TL, TM, T1f; + T1g = rio[WS(ios, 9)]; + TL = rio[WS(ios, 14)]; + TM = iio[-WS(ios, 4)]; + T1f = TL - TM; + TN = KP866025403 * (TL + TM); + T2S = T1f + T1g; + T1h = FMS(KP500000000, T1f, T1g); + } + T2W = Ta - Tf; + T38 = T2R + T2S; + T37 = T2O - T2P; + T2X = Tl - Tq; + T2Q = T2O + T2P; + T2T = T2R - T2S; + T2U = T2Q + T2T; + Tg = Ta + Tf; + Tr = Tl + Tq; + Ts = Tg + Tr; + Ty = Tu - Tx; + TD = Tz - TC; + TE = Ty + TD; + T2c = T1d + T1c; + T2d = T1i + T1h; + T2m = T2c + T2d; + TJ = TF - TI; + TO = TK - TN; + TP = TJ + TO; + T1Y = Tu + Tx; + T1Z = Tz + TC; + T20 = T1Y + T1Z; + T1e = T1c - T1d; + T1j = T1h - T1i; + T1p = T1e + T1j; + T13 = T11 - T12; + T18 = T14 + T17; + T1o = T13 - T18; + T29 = T12 + T11; + T2a = T14 - T17; + T2l = T29 + T2a; + T21 = TF + TI; + T22 = TK + TN; + T23 = T21 + T22; + } + rio[0] = T5 + Ts; + { + E T1l, T1J, T1B, T1M, TY, T1U, T1I, T1y, T1W, T1N, T1T, T1V; + { + E T19, T1k, T1z, T1A; + T19 = T13 + T18; + T1k = T1e - T1j; + T1l = FMA(KP951056516, T19, KP587785252 * T1k); + T1J = FNMS(KP951056516, T1k, KP587785252 * T19); + T1z = Ty - TD; + T1A = TJ - TO; + T1B = FMA(KP951056516, T1z, KP587785252 * T1A); + T1M = FNMS(KP951056516, T1A, KP587785252 * T1z); + } + { + E TQ, TW, TX, T1q, T1w, T1x; + TQ = KP559016994 * (TE - TP); + TW = TE + TP; + TX = FNMS(KP250000000, TW, TV); + TY = TQ + TX; + T1U = TV + TW; + T1I = TX - TQ; + T1q = KP559016994 * (T1o - T1p); + T1w = T1o + T1p; + T1x = FNMS(KP250000000, T1w, T1v); + T1y = T1q + T1x; + T1W = T1v + T1w; + T1N = T1x - T1q; + } + T1T = W[8]; + T1V = W[9]; + rio[WS(ios, 5)] = FNMS(T1V, T1W, T1T * T1U); + iio[-WS(ios, 9)] = FMA(T1V, T1U, T1T * T1W); + { + E T1Q, T1S, T1P, T1R; + T1Q = T1I + T1J; + T1S = T1N - T1M; + T1P = W[14]; + T1R = W[15]; + rio[WS(ios, 8)] = FNMS(T1R, T1S, T1P * T1Q); + iio[-WS(ios, 6)] = FMA(T1R, T1Q, T1P * T1S); + } + { + E T1m, T1C, Tt, T1n; + T1m = TY + T1l; + T1C = T1y - T1B; + Tt = W[26]; + T1n = W[27]; + rio[WS(ios, 14)] = FNMS(T1n, T1C, Tt * T1m); + iio[0] = FMA(T1n, T1m, Tt * T1C); + } + { + E T1E, T1G, T1D, T1F; + T1E = TY - T1l; + T1G = T1B + T1y; + T1D = W[20]; + T1F = W[21]; + rio[WS(ios, 11)] = FNMS(T1F, T1G, T1D * T1E); + iio[-WS(ios, 3)] = FMA(T1F, T1E, T1D * T1G); + } + { + E T1K, T1O, T1H, T1L; + T1K = T1I - T1J; + T1O = T1M + T1N; + T1H = W[2]; + T1L = W[3]; + rio[WS(ios, 2)] = FNMS(T1L, T1O, T1H * T1K); + iio[-WS(ios, 12)] = FMA(T1L, T1K, T1H * T1O); + } + } + iio[-WS(ios, 14)] = T2N + T2U; + { + E T2Y, T39, T3k, T3h, T36, T3g, T31, T3l; + T2Y = FNMS(KP951056516, T2X, KP587785252 * T2W); + T39 = FNMS(KP951056516, T38, KP587785252 * T37); + T3k = FMA(KP951056516, T2W, KP587785252 * T2X); + T3h = FMA(KP951056516, T37, KP587785252 * T38); + { + E T34, T35, T2Z, T30; + T34 = FNMS(KP250000000, Ts, T5); + T35 = KP559016994 * (Tg - Tr); + T36 = T34 - T35; + T3g = T35 + T34; + T2Z = FNMS(KP250000000, T2U, T2N); + T30 = KP559016994 * (T2Q - T2T); + T31 = T2Z - T30; + T3l = T30 + T2Z; + } + { + E T32, T3a, T2V, T33; + T32 = T2Y + T31; + T3a = T36 - T39; + T2V = W[22]; + T33 = W[23]; + iio[-WS(ios, 2)] = FMA(T2V, T32, T33 * T3a); + rio[WS(ios, 12)] = FNMS(T33, T32, T2V * T3a); + } + { + E T3o, T3q, T3n, T3p; + T3o = T3l - T3k; + T3q = T3g + T3h; + T3n = W[16]; + T3p = W[17]; + iio[-WS(ios, 5)] = FMA(T3n, T3o, T3p * T3q); + rio[WS(ios, 9)] = FNMS(T3p, T3o, T3n * T3q); + } + { + E T3c, T3e, T3b, T3d; + T3c = T36 + T39; + T3e = T31 - T2Y; + T3b = W[4]; + T3d = W[5]; + rio[WS(ios, 3)] = FNMS(T3d, T3e, T3b * T3c); + iio[-WS(ios, 11)] = FMA(T3b, T3e, T3d * T3c); + } + { + E T3i, T3m, T3f, T3j; + T3i = T3g - T3h; + T3m = T3k + T3l; + T3f = W[10]; + T3j = W[11]; + rio[WS(ios, 6)] = FNMS(T3j, T3m, T3f * T3i); + iio[-WS(ios, 8)] = FMA(T3f, T3m, T3j * T3i); + } + } + { + E T2f, T2z, T2k, T2D, T28, T2K, T2y, T2r, T2M, T2C, T2J, T2L; + { + E T2b, T2e, T2i, T2j; + T2b = T29 - T2a; + T2e = T2c - T2d; + T2f = FMA(KP951056516, T2b, KP587785252 * T2e); + T2z = FNMS(KP951056516, T2e, KP587785252 * T2b); + T2i = T1Y - T1Z; + T2j = T21 - T22; + T2k = FMA(KP951056516, T2i, KP587785252 * T2j); + T2D = FNMS(KP951056516, T2j, KP587785252 * T2i); + } + { + E T24, T26, T27, T2n, T2p, T2q; + T24 = KP559016994 * (T20 - T23); + T26 = T20 + T23; + T27 = FNMS(KP250000000, T26, T25); + T28 = T24 + T27; + T2K = T25 + T26; + T2y = T27 - T24; + T2n = KP559016994 * (T2l - T2m); + T2p = T2l + T2m; + T2q = FNMS(KP250000000, T2p, T2o); + T2r = T2n + T2q; + T2M = T2o + T2p; + T2C = T2q - T2n; + } + T2J = W[18]; + T2L = W[19]; + rio[WS(ios, 10)] = FNMS(T2L, T2M, T2J * T2K); + iio[-WS(ios, 4)] = FMA(T2L, T2K, T2J * T2M); + { + E T2u, T2w, T2t, T2v; + T2u = T28 + T2f; + T2w = T2r - T2k; + T2t = W[6]; + T2v = W[7]; + rio[WS(ios, 4)] = FNMS(T2v, T2w, T2t * T2u); + iio[-WS(ios, 10)] = FMA(T2v, T2u, T2t * T2w); + } + { + E T2g, T2s, T1X, T2h; + T2g = T28 - T2f; + T2s = T2k + T2r; + T1X = W[0]; + T2h = W[1]; + rio[WS(ios, 1)] = FNMS(T2h, T2s, T1X * T2g); + iio[-WS(ios, 13)] = FMA(T2h, T2g, T1X * T2s); + } + { + E T2A, T2E, T2x, T2B; + T2A = T2y + T2z; + T2E = T2C - T2D; + T2x = W[24]; + T2B = W[25]; + rio[WS(ios, 13)] = FNMS(T2B, T2E, T2x * T2A); + iio[-WS(ios, 1)] = FMA(T2B, T2A, T2x * T2E); + } + { + E T2G, T2I, T2F, T2H; + T2G = T2y - T2z; + T2I = T2D + T2C; + T2F = W[12]; + T2H = W[13]; + rio[WS(ios, 7)] = FNMS(T2H, T2I, T2F * T2G); + iio[-WS(ios, 7)] = FMA(T2H, T2G, T2F * T2I); + } + } + } + return W; +} + +static const tw_instr twinstr[] = { + {TW_FULL, 0, 15}, + {TW_NEXT, 1, 0} +}; + +static const hc2hc_desc desc = { 15, "hb_15", twinstr, {128, 56, 56, 0}, &GENUS, 0, 0, 0 }; + +void X(codelet_hb_15) (planner *p) { + X(khc2hc_dif_register) (p, hb_15, &desc); +} diff --git a/src/fftw3/rdft/codelets/hc2r/hb_16.c b/src/fftw3/rdft/codelets/hc2r/hb_16.c new file mode 100644 index 0000000..7fffeb9 --- /dev/null +++ b/src/fftw3/rdft/codelets/hc2r/hb_16.c @@ -0,0 +1,412 @@ +/* + * Copyright (c) 2003 Matteo Frigo + * Copyright (c) 2003 Massachusetts Institute of Technology + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +/* This file was automatically generated --- DO NOT EDIT */ +/* Generated on Sat Jul 5 22:11:37 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_hc2hc -compact -variables 4 -sign 1 -n 16 -dif -name hb_16 -include hb.h */ + +/* + * This function contains 174 FP additions, 84 FP multiplications, + * (or, 136 additions, 46 multiplications, 38 fused multiply/add), + * 50 stack variables, and 64 memory accesses + */ +/* + * Generator Id's : + * $Id: hb_16.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: hb_16.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: hb_16.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + */ + +#include "hb.h" + +static const R *hb_16(R *rio, R *iio, const R *W, stride ios, int m, int dist) +{ + DK(KP382683432, +0.382683432365089771728459984030398866761344562); + DK(KP923879532, +0.923879532511286756128183189396788286822416626); + DK(KP707106781, +0.707106781186547524400844362104849039284835938); + int i; + for (i = m - 2; i > 0; i = i - 2, rio = rio + dist, iio = iio - dist, W = W + 30) { + E T7, T2K, T30, Tw, T1a, T2e, T2k, T1B, Te, TD, T1C, T13, T2n, T2Z, T2b; + E T2L, Tm, T1v, TN, T10, T1W, T2p, T2P, T2W, Tt, T1w, TW, T11, T23, T2q; + E T2S, T2X; + { + E T3, T2c, T16, T2j, T6, T2i, T19, T2d; + { + E T1, T2, T14, T15; + T1 = rio[0]; + T2 = iio[-WS(ios, 8)]; + T3 = T1 + T2; + T2c = T1 - T2; + T14 = iio[0]; + T15 = rio[WS(ios, 8)]; + T16 = T14 - T15; + T2j = T14 + T15; + } + { + E T4, T5, T17, T18; + T4 = rio[WS(ios, 4)]; + T5 = iio[-WS(ios, 12)]; + T6 = T4 + T5; + T2i = T4 - T5; + T17 = iio[-WS(ios, 4)]; + T18 = rio[WS(ios, 12)]; + T19 = T17 - T18; + T2d = T17 + T18; + } + T7 = T3 + T6; + T2K = T2j - T2i; + T30 = T2c + T2d; + Tw = T3 - T6; + T1a = T16 - T19; + T2e = T2c - T2d; + T2k = T2i + T2j; + T1B = T16 + T19; + } + { + E Ta, T29, Tz, T28, Td, T25, TC, T26; + { + E T8, T9, Tx, Ty; + T8 = rio[WS(ios, 2)]; + T9 = iio[-WS(ios, 10)]; + Ta = T8 + T9; + T29 = T8 - T9; + Tx = iio[-WS(ios, 2)]; + Ty = rio[WS(ios, 10)]; + Tz = Tx - Ty; + T28 = Tx + Ty; + } + { + E Tb, Tc, TA, TB; + Tb = iio[-WS(ios, 14)]; + Tc = rio[WS(ios, 6)]; + Td = Tb + Tc; + T25 = Tb - Tc; + TA = iio[-WS(ios, 6)]; + TB = rio[WS(ios, 14)]; + TC = TA - TB; + T26 = TB + TA; + } + Te = Ta + Td; + TD = Tz - TC; + T1C = Tz + TC; + T13 = Td - Ta; + { + E T2l, T2m, T27, T2a; + T2l = T29 + T28; + T2m = T25 + T26; + T2n = KP707106781 * (T2l - T2m); + T2Z = KP707106781 * (T2l + T2m); + T27 = T25 - T26; + T2a = T28 - T29; + T2b = KP707106781 * (T27 - T2a); + T2L = KP707106781 * (T2a + T27); + } + } + { + E Ti, T1Q, TI, T1U, Tl, T1T, TL, T1R, TF, TM; + { + E Tg, Th, TG, TH; + Tg = rio[WS(ios, 1)]; + Th = iio[-WS(ios, 9)]; + Ti = Tg + Th; + T1Q = Tg - Th; + TG = iio[-WS(ios, 1)]; + TH = rio[WS(ios, 9)]; + TI = TG - TH; + T1U = TG + TH; + } + { + E Tj, Tk, TJ, TK; + Tj = rio[WS(ios, 5)]; + Tk = iio[-WS(ios, 13)]; + Tl = Tj + Tk; + T1T = Tj - Tk; + TJ = iio[-WS(ios, 5)]; + TK = rio[WS(ios, 13)]; + TL = TJ - TK; + T1R = TJ + TK; + } + Tm = Ti + Tl; + T1v = TI + TL; + TF = Ti - Tl; + TM = TI - TL; + TN = TF + TM; + T10 = TM - TF; + { + E T1S, T1V, T2N, T2O; + T1S = T1Q - T1R; + T1V = T1T + T1U; + T1W = FNMS(KP382683432, T1V, KP923879532 * T1S); + T2p = FMA(KP923879532, T1V, KP382683432 * T1S); + T2N = T1U - T1T; + T2O = T1Q + T1R; + T2P = FNMS(KP382683432, T2O, KP923879532 * T2N); + T2W = FMA(KP382683432, T2N, KP923879532 * T2O); + } + } + { + E Tp, T1X, TR, T21, Ts, T20, TU, T1Y, TO, TV; + { + E Tn, To, TP, TQ; + Tn = iio[-WS(ios, 15)]; + To = rio[WS(ios, 7)]; + Tp = Tn + To; + T1X = Tn - To; + TP = iio[-WS(ios, 7)]; + TQ = rio[WS(ios, 15)]; + TR = TP - TQ; + T21 = TQ + TP; + } + { + E Tq, Tr, TS, TT; + Tq = rio[WS(ios, 3)]; + Tr = iio[-WS(ios, 11)]; + Ts = Tq + Tr; + T20 = Tq - Tr; + TS = iio[-WS(ios, 3)]; + TT = rio[WS(ios, 11)]; + TU = TS - TT; + T1Y = TS + TT; + } + Tt = Tp + Ts; + T1w = TU + TR; + TO = Tp - Ts; + TV = TR - TU; + TW = TO - TV; + T11 = TO + TV; + { + E T1Z, T22, T2Q, T2R; + T1Z = T1X - T1Y; + T22 = T20 - T21; + T23 = FMA(KP923879532, T1Z, KP382683432 * T22); + T2q = FNMS(KP382683432, T1Z, KP923879532 * T22); + T2Q = T1X + T1Y; + T2R = T20 + T21; + T2S = FNMS(KP923879532, T2R, KP382683432 * T2Q); + T2X = FMA(KP923879532, T2Q, KP382683432 * T2R); + } + } + { + E Tf, Tu, T1K, T1M, T1N, T1O, T1J, T1L; + Tf = T7 + Te; + Tu = Tm + Tt; + T1K = Tf - Tu; + T1M = T1C + T1B; + T1N = T1v + T1w; + T1O = T1M - T1N; + rio[0] = Tf + Tu; + iio[-WS(ios, 15)] = T1N + T1M; + T1J = W[14]; + T1L = W[15]; + rio[WS(ios, 8)] = FNMS(T1L, T1O, T1J * T1K); + iio[-WS(ios, 7)] = FMA(T1L, T1K, T1J * T1O); + } + { + E T2U, T36, T32, T34; + { + E T2M, T2T, T2Y, T31; + T2M = T2K + T2L; + T2T = T2P + T2S; + T2U = T2M + T2T; + T36 = T2M - T2T; + T2Y = T2W + T2X; + T31 = T2Z + T30; + T32 = T2Y + T31; + T34 = T31 - T2Y; + } + { + E T2J, T2V, T33, T35; + T2J = W[28]; + T2V = W[29]; + iio[0] = FMA(T2J, T2U, T2V * T32); + rio[WS(ios, 15)] = FNMS(T2V, T2U, T2J * T32); + T33 = W[12]; + T35 = W[13]; + rio[WS(ios, 7)] = FNMS(T35, T36, T33 * T34); + iio[-WS(ios, 8)] = FMA(T33, T36, T35 * T34); + } + } + { + E TY, T1e, T1c, T1g; + { + E TE, TX, T12, T1b; + TE = Tw + TD; + TX = KP707106781 * (TN + TW); + TY = TE + TX; + T1e = TE - TX; + T12 = KP707106781 * (T10 + T11); + T1b = T13 + T1a; + T1c = T12 + T1b; + T1g = T1b - T12; + } + { + E Tv, TZ, T1d, T1f; + Tv = W[26]; + TZ = W[27]; + rio[WS(ios, 14)] = FNMS(TZ, T1c, Tv * TY); + iio[-WS(ios, 1)] = FMA(TZ, TY, Tv * T1c); + T1d = W[10]; + T1f = W[11]; + rio[WS(ios, 6)] = FNMS(T1f, T1g, T1d * T1e); + iio[-WS(ios, 9)] = FMA(T1f, T1e, T1d * T1g); + } + } + { + E T2g, T2w, T2s, T2u; + { + E T24, T2f, T2o, T2r; + T24 = T1W + T23; + T2f = T2b + T2e; + T2g = T24 + T2f; + T2w = T2f - T24; + T2o = T2k + T2n; + T2r = T2p + T2q; + T2s = T2o + T2r; + T2u = T2o - T2r; + } + { + E T1P, T2h, T2t, T2v; + T1P = W[0]; + T2h = W[1]; + rio[WS(ios, 1)] = FNMS(T2h, T2s, T1P * T2g); + iio[-WS(ios, 14)] = FMA(T1P, T2s, T2h * T2g); + T2t = W[16]; + T2v = W[17]; + iio[-WS(ios, 6)] = FMA(T2t, T2u, T2v * T2w); + rio[WS(ios, 9)] = FNMS(T2v, T2u, T2t * T2w); + } + } + { + E T1k, T1q, T1o, T1s; + { + E T1i, T1j, T1m, T1n; + T1i = Tw - TD; + T1j = KP707106781 * (T11 - T10); + T1k = T1i + T1j; + T1q = T1i - T1j; + T1m = KP707106781 * (TN - TW); + T1n = T1a - T13; + T1o = T1m + T1n; + T1s = T1n - T1m; + } + { + E T1h, T1l, T1p, T1r; + T1h = W[2]; + T1l = W[3]; + rio[WS(ios, 2)] = FNMS(T1l, T1o, T1h * T1k); + iio[-WS(ios, 13)] = FMA(T1l, T1k, T1h * T1o); + T1p = W[18]; + T1r = W[19]; + rio[WS(ios, 10)] = FNMS(T1r, T1s, T1p * T1q); + iio[-WS(ios, 5)] = FMA(T1r, T1q, T1p * T1s); + } + } + { + E T2A, T2I, T2E, T2G; + { + E T2y, T2z, T2C, T2D; + T2y = T2k - T2n; + T2z = T23 - T1W; + T2A = T2y + T2z; + T2I = T2y - T2z; + T2C = T2p - T2q; + T2D = T2e - T2b; + T2E = T2C + T2D; + T2G = T2D - T2C; + } + { + E T2x, T2B, T2F, T2H; + T2x = W[24]; + T2B = W[25]; + iio[-WS(ios, 2)] = FMA(T2x, T2A, T2B * T2E); + rio[WS(ios, 13)] = FNMS(T2B, T2A, T2x * T2E); + T2F = W[8]; + T2H = W[9]; + rio[WS(ios, 5)] = FNMS(T2H, T2I, T2F * T2G); + iio[-WS(ios, 10)] = FMA(T2F, T2I, T2H * T2G); + } + } + { + E T1y, T1G, T1E, T1I; + { + E T1u, T1x, T1A, T1D; + T1u = T7 - Te; + T1x = T1v - T1w; + T1y = T1u + T1x; + T1G = T1u - T1x; + T1A = Tt - Tm; + T1D = T1B - T1C; + T1E = T1A + T1D; + T1I = T1D - T1A; + } + { + E T1t, T1z, T1F, T1H; + T1t = W[22]; + T1z = W[23]; + rio[WS(ios, 12)] = FNMS(T1z, T1E, T1t * T1y); + iio[-WS(ios, 3)] = FMA(T1z, T1y, T1t * T1E); + T1F = W[6]; + T1H = W[7]; + rio[WS(ios, 4)] = FNMS(T1H, T1I, T1F * T1G); + iio[-WS(ios, 11)] = FMA(T1H, T1G, T1F * T1I); + } + } + { + E T3a, T3i, T3e, T3g; + { + E T38, T39, T3c, T3d; + T38 = T2S - T2P; + T39 = T30 - T2Z; + T3a = T38 + T39; + T3i = T39 - T38; + T3c = T2K - T2L; + T3d = T2W - T2X; + T3e = T3c + T3d; + T3g = T3c - T3d; + } + { + E T37, T3b, T3f, T3h; + T37 = W[4]; + T3b = W[5]; + rio[WS(ios, 3)] = FNMS(T3b, T3e, T37 * T3a); + iio[-WS(ios, 12)] = FMA(T37, T3e, T3b * T3a); + T3f = W[20]; + T3h = W[21]; + iio[-WS(ios, 4)] = FMA(T3f, T3g, T3h * T3i); + rio[WS(ios, 11)] = FNMS(T3h, T3g, T3f * T3i); + } + } + } + return W; +} + +static const tw_instr twinstr[] = { + {TW_FULL, 0, 16}, + {TW_NEXT, 1, 0} +}; + +static const hc2hc_desc desc = { 16, "hb_16", twinstr, {136, 46, 38, 0}, &GENUS, 0, 0, 0 }; + +void X(codelet_hb_16) (planner *p) { + X(khc2hc_dif_register) (p, hb_16, &desc); +} diff --git a/src/fftw3/rdft/codelets/hc2r/hb_2.c b/src/fftw3/rdft/codelets/hc2r/hb_2.c new file mode 100644 index 0000000..91740d2 --- /dev/null +++ b/src/fftw3/rdft/codelets/hc2r/hb_2.c @@ -0,0 +1,72 @@ +/* + * Copyright (c) 2003 Matteo Frigo + * Copyright (c) 2003 Massachusetts Institute of Technology + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +/* This file was automatically generated --- DO NOT EDIT */ +/* Generated on Sat Jul 5 22:11:22 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_hc2hc -compact -variables 4 -sign 1 -n 2 -dif -name hb_2 -include hb.h */ + +/* + * This function contains 6 FP additions, 4 FP multiplications, + * (or, 4 additions, 2 multiplications, 2 fused multiply/add), + * 9 stack variables, and 8 memory accesses + */ +/* + * Generator Id's : + * $Id: hb_2.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: hb_2.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: hb_2.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + */ + +#include "hb.h" + +static const R *hb_2(R *rio, R *iio, const R *W, stride ios, int m, int dist) +{ + int i; + for (i = m - 2; i > 0; i = i - 2, rio = rio + dist, iio = iio - dist, W = W + 2) { + E T1, T2, T6, T3, T4, T8, T5, T7; + T1 = rio[0]; + T2 = iio[-WS(ios, 1)]; + T6 = T1 - T2; + T3 = iio[0]; + T4 = rio[WS(ios, 1)]; + T8 = T3 + T4; + rio[0] = T1 + T2; + iio[-WS(ios, 1)] = T3 - T4; + T5 = W[0]; + T7 = W[1]; + rio[WS(ios, 1)] = FNMS(T7, T8, T5 * T6); + iio[0] = FMA(T7, T6, T5 * T8); + } + return W; +} + +static const tw_instr twinstr[] = { + {TW_FULL, 0, 2}, + {TW_NEXT, 1, 0} +}; + +static const hc2hc_desc desc = { 2, "hb_2", twinstr, {4, 2, 2, 0}, &GENUS, 0, 0, 0 }; + +void X(codelet_hb_2) (planner *p) { + X(khc2hc_dif_register) (p, hb_2, &desc); +} diff --git a/src/fftw3/rdft/codelets/hc2r/hb_3.c b/src/fftw3/rdft/codelets/hc2r/hb_3.c new file mode 100644 index 0000000..b2362cb --- /dev/null +++ b/src/fftw3/rdft/codelets/hc2r/hb_3.c @@ -0,0 +1,97 @@ +/* + * Copyright (c) 2003 Matteo Frigo + * Copyright (c) 2003 Massachusetts Institute of Technology + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +/* This file was automatically generated --- DO NOT EDIT */ +/* Generated on Sat Jul 5 22:11:22 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_hc2hc -compact -variables 4 -sign 1 -n 3 -dif -name hb_3 -include hb.h */ + +/* + * This function contains 16 FP additions, 12 FP multiplications, + * (or, 10 additions, 6 multiplications, 6 fused multiply/add), + * 15 stack variables, and 12 memory accesses + */ +/* + * Generator Id's : + * $Id: hb_3.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: hb_3.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: hb_3.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + */ + +#include "hb.h" + +static const R *hb_3(R *rio, R *iio, const R *W, stride ios, int m, int dist) +{ + DK(KP866025403, +0.866025403784438646763723170752936183471402627); + DK(KP500000000, +0.500000000000000000000000000000000000000000000); + int i; + for (i = m - 2; i > 0; i = i - 2, rio = rio + dist, iio = iio - dist, W = W + 4) { + E T1, T4, Ta, Te, T5, T8, Tb, Tf; + { + E T2, T3, T6, T7; + T1 = rio[0]; + T2 = rio[WS(ios, 1)]; + T3 = iio[-WS(ios, 2)]; + T4 = T2 + T3; + Ta = FNMS(KP500000000, T4, T1); + Te = KP866025403 * (T2 - T3); + T5 = iio[0]; + T6 = rio[WS(ios, 2)]; + T7 = iio[-WS(ios, 1)]; + T8 = T6 - T7; + Tb = KP866025403 * (T6 + T7); + Tf = FMA(KP500000000, T8, T5); + } + rio[0] = T1 + T4; + iio[-WS(ios, 2)] = T5 - T8; + { + E Ti, Tk, Th, Tj; + Ti = Tf - Te; + Tk = Ta + Tb; + Th = W[2]; + Tj = W[3]; + iio[0] = FMA(Th, Ti, Tj * Tk); + rio[WS(ios, 2)] = FNMS(Tj, Ti, Th * Tk); + } + { + E Tc, Tg, T9, Td; + Tc = Ta - Tb; + Tg = Te + Tf; + T9 = W[0]; + Td = W[1]; + rio[WS(ios, 1)] = FNMS(Td, Tg, T9 * Tc); + iio[-WS(ios, 1)] = FMA(T9, Tg, Td * Tc); + } + } + return W; +} + +static const tw_instr twinstr[] = { + {TW_FULL, 0, 3}, + {TW_NEXT, 1, 0} +}; + +static const hc2hc_desc desc = { 3, "hb_3", twinstr, {10, 6, 6, 0}, &GENUS, 0, 0, 0 }; + +void X(codelet_hb_3) (planner *p) { + X(khc2hc_dif_register) (p, hb_3, &desc); +} diff --git a/src/fftw3/rdft/codelets/hc2r/hb_32.c b/src/fftw3/rdft/codelets/hc2r/hb_32.c new file mode 100644 index 0000000..f3358ab --- /dev/null +++ b/src/fftw3/rdft/codelets/hc2r/hb_32.c @@ -0,0 +1,890 @@ +/* + * Copyright (c) 2003 Matteo Frigo + * Copyright (c) 2003 Massachusetts Institute of Technology + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +/* This file was automatically generated --- DO NOT EDIT */ +/* Generated on Sat Jul 5 22:11:39 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_hc2hc -compact -variables 4 -sign 1 -n 32 -dif -name hb_32 -include hb.h */ + +/* + * This function contains 434 FP additions, 208 FP multiplications, + * (or, 340 additions, 114 multiplications, 94 fused multiply/add), + * 98 stack variables, and 128 memory accesses + */ +/* + * Generator Id's : + * $Id: hb_32.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: hb_32.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: hb_32.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + */ + +#include "hb.h" + +static const R *hb_32(R *rio, R *iio, const R *W, stride ios, int m, int dist) +{ + DK(KP555570233, +0.555570233019602224742830813948532874374937191); + DK(KP831469612, +0.831469612302545237078788377617905756738560812); + DK(KP195090322, +0.195090322016128267848284868477022240927691618); + DK(KP980785280, +0.980785280403230449126182236134239036973933731); + DK(KP382683432, +0.382683432365089771728459984030398866761344562); + DK(KP923879532, +0.923879532511286756128183189396788286822416626); + DK(KP707106781, +0.707106781186547524400844362104849039284835938); + int i; + for (i = m - 2; i > 0; i = i - 2, rio = rio + dist, iio = iio - dist, W = W + 62) { + E T5n, T6y, T77, T5u, Tf, T3i, T5x, T76, T3G, T47, T1a, T2I, T5k, T6z, T2o; + E T2Y, Tu, T3D, T6D, T73, T6G, T74, T1j, T2d, T1s, T2e, T55, T5z, T5c, T5A; + E T3l, T48, TK, T3n, T6L, T7t, T6O, T7s, T1D, T2L, T1M, T2M, T4w, T62, T4D; + E T61, T3q, T41, TZ, T3s, T6S, T7w, T6V, T7v, T1W, T2O, T25, T2P, T4P, T64; + E T4W, T65, T3v, T42; + { + E T3, T5l, T2j, T5t, T6, T5s, T2m, T5m, Ta, T5i, T15, T5h, Td, T5e, T18; + E T5f; + { + E T1, T2, T2h, T2i; + T1 = rio[0]; + T2 = iio[-WS(ios, 16)]; + T3 = T1 + T2; + T5l = T1 - T2; + T2h = iio[0]; + T2i = rio[WS(ios, 16)]; + T2j = T2h - T2i; + T5t = T2h + T2i; + } + { + E T4, T5, T2k, T2l; + T4 = rio[WS(ios, 8)]; + T5 = iio[-WS(ios, 24)]; + T6 = T4 + T5; + T5s = T4 - T5; + T2k = iio[-WS(ios, 8)]; + T2l = rio[WS(ios, 24)]; + T2m = T2k - T2l; + T5m = T2k + T2l; + } + { + E T8, T9, T13, T14; + T8 = rio[WS(ios, 4)]; + T9 = iio[-WS(ios, 20)]; + Ta = T8 + T9; + T5i = T8 - T9; + T13 = iio[-WS(ios, 4)]; + T14 = rio[WS(ios, 20)]; + T15 = T13 - T14; + T5h = T13 + T14; + } + { + E Tb, Tc, T16, T17; + Tb = iio[-WS(ios, 28)]; + Tc = rio[WS(ios, 12)]; + Td = Tb + Tc; + T5e = Tb - Tc; + T16 = iio[-WS(ios, 12)]; + T17 = rio[WS(ios, 28)]; + T18 = T16 - T17; + T5f = T17 + T16; + } + { + E T7, Te, T12, T19; + T5n = T5l - T5m; + T6y = T5t - T5s; + T77 = T5l + T5m; + T5u = T5s + T5t; + T7 = T3 + T6; + Te = Ta + Td; + Tf = T7 + Te; + T3i = T7 - Te; + { + E T5v, T5w, T3E, T3F; + T5v = T5i + T5h; + T5w = T5e + T5f; + T5x = KP707106781 * (T5v - T5w); + T76 = KP707106781 * (T5v + T5w); + T3E = T2j + T2m; + T3F = T15 + T18; + T3G = T3E - T3F; + T47 = T3F + T3E; + } + T12 = T3 - T6; + T19 = T15 - T18; + T1a = T12 + T19; + T2I = T12 - T19; + { + E T5g, T5j, T2g, T2n; + T5g = T5e - T5f; + T5j = T5h - T5i; + T5k = KP707106781 * (T5g - T5j); + T6z = KP707106781 * (T5j + T5g); + T2g = Td - Ta; + T2n = T2j - T2m; + T2o = T2g + T2n; + T2Y = T2n - T2g; + } + } + } + { + E Ti, T4Z, T1e, T53, Tl, T52, T1h, T50, Tp, T56, T1n, T5a, Ts, T59, T1q; + E T57; + { + E Tg, Th, T1c, T1d; + Tg = rio[WS(ios, 2)]; + Th = iio[-WS(ios, 18)]; + Ti = Tg + Th; + T4Z = Tg - Th; + T1c = iio[-WS(ios, 2)]; + T1d = rio[WS(ios, 18)]; + T1e = T1c - T1d; + T53 = T1c + T1d; + } + { + E Tj, Tk, T1f, T1g; + Tj = rio[WS(ios, 10)]; + Tk = iio[-WS(ios, 26)]; + Tl = Tj + Tk; + T52 = Tj - Tk; + T1f = iio[-WS(ios, 10)]; + T1g = rio[WS(ios, 26)]; + T1h = T1f - T1g; + T50 = T1f + T1g; + } + { + E Tn, To, T1l, T1m; + Tn = iio[-WS(ios, 30)]; + To = rio[WS(ios, 14)]; + Tp = Tn + To; + T56 = Tn - To; + T1l = iio[-WS(ios, 14)]; + T1m = rio[WS(ios, 30)]; + T1n = T1l - T1m; + T5a = T1m + T1l; + } + { + E Tq, Tr, T1o, T1p; + Tq = rio[WS(ios, 6)]; + Tr = iio[-WS(ios, 22)]; + Ts = Tq + Tr; + T59 = Tq - Tr; + T1o = iio[-WS(ios, 6)]; + T1p = rio[WS(ios, 22)]; + T1q = T1o - T1p; + T57 = T1o + T1p; + } + { + E Tm, Tt, T6B, T6C; + Tm = Ti + Tl; + Tt = Tp + Ts; + Tu = Tm + Tt; + T3D = Tt - Tm; + T6B = T53 - T52; + T6C = T4Z + T50; + T6D = FNMS(KP382683432, T6C, KP923879532 * T6B); + T73 = FMA(KP382683432, T6B, KP923879532 * T6C); + } + { + E T6E, T6F, T1b, T1i; + T6E = T56 + T57; + T6F = T59 + T5a; + T6G = FNMS(KP923879532, T6F, KP382683432 * T6E); + T74 = FMA(KP923879532, T6E, KP382683432 * T6F); + T1b = Ti - Tl; + T1i = T1e - T1h; + T1j = T1b + T1i; + T2d = T1i - T1b; + } + { + E T1k, T1r, T51, T54; + T1k = Tp - Ts; + T1r = T1n - T1q; + T1s = T1k - T1r; + T2e = T1k + T1r; + T51 = T4Z - T50; + T54 = T52 + T53; + T55 = FNMS(KP382683432, T54, KP923879532 * T51); + T5z = FMA(KP923879532, T54, KP382683432 * T51); + } + { + E T58, T5b, T3j, T3k; + T58 = T56 - T57; + T5b = T59 - T5a; + T5c = FMA(KP923879532, T58, KP382683432 * T5b); + T5A = FNMS(KP382683432, T58, KP923879532 * T5b); + T3j = T1e + T1h; + T3k = T1q + T1n; + T3l = T3j - T3k; + T48 = T3j + T3k; + } + } + { + E Ty, T4t, T1H, T4y, TB, T4x, T1K, T4u, TI, T4B, T1B, T4o, TF, T4A, T1y; + E T4r; + { + E Tw, Tx, T1I, T1J; + Tw = rio[WS(ios, 1)]; + Tx = iio[-WS(ios, 17)]; + Ty = Tw + Tx; + T4t = Tw - Tx; + { + E T1F, T1G, Tz, TA; + T1F = iio[-WS(ios, 1)]; + T1G = rio[WS(ios, 17)]; + T1H = T1F - T1G; + T4y = T1F + T1G; + Tz = rio[WS(ios, 9)]; + TA = iio[-WS(ios, 25)]; + TB = Tz + TA; + T4x = Tz - TA; + } + T1I = iio[-WS(ios, 9)]; + T1J = rio[WS(ios, 25)]; + T1K = T1I - T1J; + T4u = T1I + T1J; + { + E TG, TH, T4m, T1z, T1A, T4n; + TG = iio[-WS(ios, 29)]; + TH = rio[WS(ios, 13)]; + T4m = TG - TH; + T1z = iio[-WS(ios, 13)]; + T1A = rio[WS(ios, 29)]; + T4n = T1A + T1z; + TI = TG + TH; + T4B = T4m + T4n; + T1B = T1z - T1A; + T4o = T4m - T4n; + } + { + E TD, TE, T4q, T1w, T1x, T4p; + TD = rio[WS(ios, 5)]; + TE = iio[-WS(ios, 21)]; + T4q = TD - TE; + T1w = iio[-WS(ios, 5)]; + T1x = rio[WS(ios, 21)]; + T4p = T1w + T1x; + TF = TD + TE; + T4A = T4q + T4p; + T1y = T1w - T1x; + T4r = T4p - T4q; + } + } + { + E TC, TJ, T6J, T6K; + TC = Ty + TB; + TJ = TF + TI; + TK = TC + TJ; + T3n = TC - TJ; + T6J = T4y - T4x; + T6K = KP707106781 * (T4r + T4o); + T6L = T6J + T6K; + T7t = T6J - T6K; + } + { + E T6M, T6N, T1v, T1C; + T6M = KP707106781 * (T4A + T4B); + T6N = T4t + T4u; + T6O = T6M + T6N; + T7s = T6N - T6M; + T1v = Ty - TB; + T1C = T1y - T1B; + T1D = T1v + T1C; + T2L = T1v - T1C; + } + { + E T1E, T1L, T4s, T4v; + T1E = TI - TF; + T1L = T1H - T1K; + T1M = T1E + T1L; + T2M = T1L - T1E; + T4s = KP707106781 * (T4o - T4r); + T4v = T4t - T4u; + T4w = T4s + T4v; + T62 = T4v - T4s; + } + { + E T4z, T4C, T3o, T3p; + T4z = T4x + T4y; + T4C = KP707106781 * (T4A - T4B); + T4D = T4z + T4C; + T61 = T4z - T4C; + T3o = T1H + T1K; + T3p = T1y + T1B; + T3q = T3o - T3p; + T41 = T3p + T3o; + } + } + { + E TN, T4T, T20, T4N, TQ, T4M, T23, T4U, TX, T4Q, T1U, T4K, TU, T4R, T1R; + E T4H; + { + E TL, TM, T21, T22; + TL = iio[-WS(ios, 31)]; + TM = rio[WS(ios, 15)]; + TN = TL + TM; + T4T = TL - TM; + { + E T1Y, T1Z, TO, TP; + T1Y = iio[-WS(ios, 15)]; + T1Z = rio[WS(ios, 31)]; + T20 = T1Y - T1Z; + T4N = T1Z + T1Y; + TO = rio[WS(ios, 7)]; + TP = iio[-WS(ios, 23)]; + TQ = TO + TP; + T4M = TO - TP; + } + T21 = iio[-WS(ios, 7)]; + T22 = rio[WS(ios, 23)]; + T23 = T21 - T22; + T4U = T21 + T22; + { + E TV, TW, T4I, T1S, T1T, T4J; + TV = iio[-WS(ios, 27)]; + TW = rio[WS(ios, 11)]; + T4I = TV - TW; + T1S = iio[-WS(ios, 11)]; + T1T = rio[WS(ios, 27)]; + T4J = T1T + T1S; + TX = TV + TW; + T4Q = T4I - T4J; + T1U = T1S - T1T; + T4K = T4I + T4J; + } + { + E TS, TT, T4F, T1P, T1Q, T4G; + TS = rio[WS(ios, 3)]; + TT = iio[-WS(ios, 19)]; + T4F = TS - TT; + T1P = iio[-WS(ios, 3)]; + T1Q = rio[WS(ios, 19)]; + T4G = T1P + T1Q; + TU = TS + TT; + T4R = T4G - T4F; + T1R = T1P - T1Q; + T4H = T4F + T4G; + } + } + { + E TR, TY, T6Q, T6R; + TR = TN + TQ; + TY = TU + TX; + TZ = TR + TY; + T3s = TR - TY; + T6Q = KP707106781 * (T4R + T4Q); + T6R = T4M + T4N; + T6S = T6Q - T6R; + T7w = T6Q + T6R; + } + { + E T6T, T6U, T1O, T1V; + T6T = KP707106781 * (T4H + T4K); + T6U = T4T + T4U; + T6V = T6T + T6U; + T7v = T6U - T6T; + T1O = TN - TQ; + T1V = T1R - T1U; + T1W = T1O + T1V; + T2O = T1O - T1V; + } + { + E T1X, T24, T4L, T4O; + T1X = TX - TU; + T24 = T20 - T23; + T25 = T1X + T24; + T2P = T24 - T1X; + T4L = KP707106781 * (T4H - T4K); + T4O = T4M - T4N; + T4P = T4L + T4O; + T64 = T4O - T4L; + } + { + E T4S, T4V, T3t, T3u; + T4S = KP707106781 * (T4Q - T4R); + T4V = T4T - T4U; + T4W = T4S + T4V; + T65 = T4V - T4S; + T3t = T20 + T23; + T3u = T1R + T1U; + T3v = T3t - T3u; + T42 = T3u + T3t; + } + } + { + E Tv, T10, T4g, T4i, T4j, T4k, T4f, T4h; + Tv = Tf + Tu; + T10 = TK + TZ; + T4g = Tv - T10; + T4i = T48 + T47; + T4j = T41 + T42; + T4k = T4i - T4j; + rio[0] = Tv + T10; + iio[-WS(ios, 31)] = T4j + T4i; + T4f = W[30]; + T4h = W[31]; + rio[WS(ios, 16)] = FNMS(T4h, T4k, T4f * T4g); + iio[-WS(ios, 15)] = FMA(T4h, T4g, T4f * T4k); + } + { + E T44, T4c, T4a, T4e; + { + E T40, T43, T46, T49; + T40 = Tf - Tu; + T43 = T41 - T42; + T44 = T40 + T43; + T4c = T40 - T43; + T46 = TZ - TK; + T49 = T47 - T48; + T4a = T46 + T49; + T4e = T49 - T46; + } + { + E T3Z, T45, T4b, T4d; + T3Z = W[46]; + T45 = W[47]; + rio[WS(ios, 24)] = FNMS(T45, T4a, T3Z * T44); + iio[-WS(ios, 7)] = FMA(T45, T44, T3Z * T4a); + T4b = W[14]; + T4d = W[15]; + rio[WS(ios, 8)] = FNMS(T4d, T4e, T4b * T4c); + iio[-WS(ios, 23)] = FMA(T4d, T4c, T4b * T4e); + } + } + { + E T3m, T3H, T3T, T3O, T3C, T3P, T3x, T3S; + T3m = T3i + T3l; + T3H = T3D + T3G; + T3T = T3G - T3D; + T3O = T3i - T3l; + { + E T3A, T3B, T3r, T3w; + T3A = T3q - T3n; + T3B = T3s + T3v; + T3C = KP707106781 * (T3A + T3B); + T3P = KP707106781 * (T3B - T3A); + T3r = T3n + T3q; + T3w = T3s - T3v; + T3x = KP707106781 * (T3r + T3w); + T3S = KP707106781 * (T3r - T3w); + } + { + E T3y, T3I, T3h, T3z; + T3y = T3m + T3x; + T3I = T3C + T3H; + T3h = W[54]; + T3z = W[55]; + rio[WS(ios, 28)] = FNMS(T3z, T3I, T3h * T3y); + iio[-WS(ios, 3)] = FMA(T3z, T3y, T3h * T3I); + } + { + E T3W, T3Y, T3V, T3X; + T3W = T3O - T3P; + T3Y = T3T - T3S; + T3V = W[38]; + T3X = W[39]; + rio[WS(ios, 20)] = FNMS(T3X, T3Y, T3V * T3W); + iio[-WS(ios, 11)] = FMA(T3X, T3W, T3V * T3Y); + } + { + E T3K, T3M, T3J, T3L; + T3K = T3m - T3x; + T3M = T3H - T3C; + T3J = W[22]; + T3L = W[23]; + rio[WS(ios, 12)] = FNMS(T3L, T3M, T3J * T3K); + iio[-WS(ios, 19)] = FMA(T3L, T3K, T3J * T3M); + } + { + E T3Q, T3U, T3N, T3R; + T3Q = T3O + T3P; + T3U = T3S + T3T; + T3N = W[6]; + T3R = W[7]; + rio[WS(ios, 4)] = FNMS(T3R, T3U, T3N * T3Q); + iio[-WS(ios, 27)] = FMA(T3R, T3Q, T3N * T3U); + } + } + { + E T2K, T36, T2Z, T3b, T2R, T3a, T2W, T37, T2J, T2X; + T2J = KP707106781 * (T2e - T2d); + T2K = T2I + T2J; + T36 = T2I - T2J; + T2X = KP707106781 * (T1j - T1s); + T2Z = T2X + T2Y; + T3b = T2Y - T2X; + { + E T2N, T2Q, T2U, T2V; + T2N = FNMS(KP382683432, T2M, KP923879532 * T2L); + T2Q = FMA(KP923879532, T2O, KP382683432 * T2P); + T2R = T2N + T2Q; + T3a = T2Q - T2N; + T2U = FMA(KP382683432, T2L, KP923879532 * T2M); + T2V = FNMS(KP382683432, T2O, KP923879532 * T2P); + T2W = T2U + T2V; + T37 = T2U - T2V; + } + { + E T2S, T30, T2H, T2T; + T2S = T2K + T2R; + T30 = T2W + T2Z; + T2H = W[2]; + T2T = W[3]; + rio[WS(ios, 2)] = FNMS(T2T, T30, T2H * T2S); + iio[-WS(ios, 29)] = FMA(T2T, T2S, T2H * T30); + } + { + E T3e, T3g, T3d, T3f; + T3e = T36 - T37; + T3g = T3b - T3a; + T3d = W[18]; + T3f = W[19]; + rio[WS(ios, 10)] = FNMS(T3f, T3g, T3d * T3e); + iio[-WS(ios, 21)] = FMA(T3f, T3e, T3d * T3g); + } + { + E T32, T34, T31, T33; + T32 = T2K - T2R; + T34 = T2Z - T2W; + T31 = W[34]; + T33 = W[35]; + rio[WS(ios, 18)] = FNMS(T33, T34, T31 * T32); + iio[-WS(ios, 13)] = FMA(T33, T32, T31 * T34); + } + { + E T38, T3c, T35, T39; + T38 = T36 + T37; + T3c = T3a + T3b; + T35 = W[50]; + T39 = W[51]; + rio[WS(ios, 26)] = FNMS(T39, T3c, T35 * T38); + iio[-WS(ios, 5)] = FMA(T39, T38, T35 * T3c); + } + } + { + E T1u, T2w, T2p, T2B, T27, T2A, T2c, T2x, T1t, T2f; + T1t = KP707106781 * (T1j + T1s); + T1u = T1a + T1t; + T2w = T1a - T1t; + T2f = KP707106781 * (T2d + T2e); + T2p = T2f + T2o; + T2B = T2o - T2f; + { + E T1N, T26, T2a, T2b; + T1N = FMA(KP923879532, T1D, KP382683432 * T1M); + T26 = FNMS(KP382683432, T25, KP923879532 * T1W); + T27 = T1N + T26; + T2A = T1N - T26; + T2a = FNMS(KP382683432, T1D, KP923879532 * T1M); + T2b = FMA(KP382683432, T1W, KP923879532 * T25); + T2c = T2a + T2b; + T2x = T2b - T2a; + } + { + E T28, T2q, T11, T29; + T28 = T1u + T27; + T2q = T2c + T2p; + T11 = W[58]; + T29 = W[59]; + rio[WS(ios, 30)] = FNMS(T29, T2q, T11 * T28); + iio[-WS(ios, 1)] = FMA(T29, T28, T11 * T2q); + } + { + E T2E, T2G, T2D, T2F; + T2E = T2w - T2x; + T2G = T2B - T2A; + T2D = W[42]; + T2F = W[43]; + rio[WS(ios, 22)] = FNMS(T2F, T2G, T2D * T2E); + iio[-WS(ios, 9)] = FMA(T2F, T2E, T2D * T2G); + } + { + E T2s, T2u, T2r, T2t; + T2s = T1u - T27; + T2u = T2p - T2c; + T2r = W[26]; + T2t = W[27]; + rio[WS(ios, 14)] = FNMS(T2t, T2u, T2r * T2s); + iio[-WS(ios, 17)] = FMA(T2t, T2s, T2r * T2u); + } + { + E T2y, T2C, T2v, T2z; + T2y = T2w + T2x; + T2C = T2A + T2B; + T2v = W[10]; + T2z = W[11]; + rio[WS(ios, 6)] = FNMS(T2z, T2C, T2v * T2y); + iio[-WS(ios, 25)] = FMA(T2z, T2y, T2v * T2C); + } + } + { + E T4Y, T5N, T5F, T5Q, T5p, T5R, T5C, T5M; + { + E T4E, T4X, T5D, T5E; + T4E = FNMS(KP195090322, T4D, KP980785280 * T4w); + T4X = FMA(KP195090322, T4P, KP980785280 * T4W); + T4Y = T4E + T4X; + T5N = T4X - T4E; + T5D = FMA(KP980785280, T4D, KP195090322 * T4w); + T5E = FNMS(KP195090322, T4W, KP980785280 * T4P); + T5F = T5D + T5E; + T5Q = T5D - T5E; + } + { + E T5d, T5o, T5y, T5B; + T5d = T55 + T5c; + T5o = T5k + T5n; + T5p = T5d + T5o; + T5R = T5o - T5d; + T5y = T5u + T5x; + T5B = T5z + T5A; + T5C = T5y + T5B; + T5M = T5y - T5B; + } + { + E T5q, T5G, T4l, T5r; + T5q = T4Y + T5p; + T5G = T5C + T5F; + T4l = W[0]; + T5r = W[1]; + rio[WS(ios, 1)] = FNMS(T5r, T5G, T4l * T5q); + iio[-WS(ios, 30)] = FMA(T4l, T5G, T5r * T5q); + } + { + E T5U, T5W, T5T, T5V; + T5U = T5R - T5Q; + T5W = T5M - T5N; + T5T = W[16]; + T5V = W[17]; + rio[WS(ios, 9)] = FNMS(T5V, T5W, T5T * T5U); + iio[-WS(ios, 22)] = FMA(T5T, T5W, T5V * T5U); + } + { + E T5I, T5K, T5H, T5J; + T5I = T5C - T5F; + T5K = T5p - T4Y; + T5H = W[32]; + T5J = W[33]; + iio[-WS(ios, 14)] = FMA(T5H, T5I, T5J * T5K); + rio[WS(ios, 17)] = FNMS(T5J, T5I, T5H * T5K); + } + { + E T5O, T5S, T5L, T5P; + T5O = T5M + T5N; + T5S = T5Q + T5R; + T5L = W[48]; + T5P = W[49]; + iio[-WS(ios, 6)] = FMA(T5L, T5O, T5P * T5S); + rio[WS(ios, 25)] = FNMS(T5P, T5O, T5L * T5S); + } + } + { + E T60, T6q, T6f, T6n, T67, T6m, T6c, T6r; + { + E T5Y, T5Z, T6d, T6e; + T5Y = T5u - T5x; + T5Z = T5c - T55; + T60 = T5Y + T5Z; + T6q = T5Y - T5Z; + T6d = T5z - T5A; + T6e = T5n - T5k; + T6f = T6d + T6e; + T6n = T6e - T6d; + } + { + E T63, T66, T6a, T6b; + T63 = FNMS(KP555570233, T62, KP831469612 * T61); + T66 = FMA(KP831469612, T64, KP555570233 * T65); + T67 = T63 + T66; + T6m = T66 - T63; + T6a = FMA(KP555570233, T61, KP831469612 * T62); + T6b = FNMS(KP555570233, T64, KP831469612 * T65); + T6c = T6a + T6b; + T6r = T6a - T6b; + } + { + E T68, T6g, T5X, T69; + T68 = T60 + T67; + T6g = T6c + T6f; + T5X = W[56]; + T69 = W[57]; + iio[-WS(ios, 2)] = FMA(T5X, T68, T69 * T6g); + rio[WS(ios, 29)] = FNMS(T69, T68, T5X * T6g); + } + { + E T6u, T6w, T6t, T6v; + T6u = T6q - T6r; + T6w = T6n - T6m; + T6t = W[40]; + T6v = W[41]; + iio[-WS(ios, 10)] = FMA(T6t, T6u, T6v * T6w); + rio[WS(ios, 21)] = FNMS(T6v, T6u, T6t * T6w); + } + { + E T6i, T6k, T6h, T6j; + T6i = T6f - T6c; + T6k = T60 - T67; + T6h = W[24]; + T6j = W[25]; + rio[WS(ios, 13)] = FNMS(T6j, T6k, T6h * T6i); + iio[-WS(ios, 18)] = FMA(T6h, T6k, T6j * T6i); + } + { + E T6o, T6s, T6l, T6p; + T6o = T6m + T6n; + T6s = T6q + T6r; + T6l = W[8]; + T6p = W[9]; + rio[WS(ios, 5)] = FNMS(T6p, T6s, T6l * T6o); + iio[-WS(ios, 26)] = FMA(T6l, T6s, T6p * T6o); + } + } + { + E T7y, T7R, T7J, T7U, T7B, T7V, T7G, T7Q; + { + E T7u, T7x, T7H, T7I; + T7u = FNMS(KP555570233, T7t, KP831469612 * T7s); + T7x = FNMS(KP555570233, T7w, KP831469612 * T7v); + T7y = T7u + T7x; + T7R = T7x - T7u; + T7H = FMA(KP831469612, T7t, KP555570233 * T7s); + T7I = FMA(KP831469612, T7w, KP555570233 * T7v); + T7J = T7H - T7I; + T7U = T7H + T7I; + } + { + E T7z, T7A, T7E, T7F; + T7z = T6G - T6D; + T7A = T77 - T76; + T7B = T7z + T7A; + T7V = T7A - T7z; + T7E = T6y - T6z; + T7F = T73 - T74; + T7G = T7E + T7F; + T7Q = T7E - T7F; + } + { + E T7C, T7K, T7r, T7D; + T7C = T7y + T7B; + T7K = T7G + T7J; + T7r = W[4]; + T7D = W[5]; + rio[WS(ios, 3)] = FNMS(T7D, T7K, T7r * T7C); + iio[-WS(ios, 28)] = FMA(T7r, T7K, T7D * T7C); + } + { + E T7Y, T80, T7X, T7Z; + T7Y = T7V - T7U; + T80 = T7Q - T7R; + T7X = W[20]; + T7Z = W[21]; + rio[WS(ios, 11)] = FNMS(T7Z, T80, T7X * T7Y); + iio[-WS(ios, 20)] = FMA(T7X, T80, T7Z * T7Y); + } + { + E T7M, T7O, T7L, T7N; + T7M = T7G - T7J; + T7O = T7B - T7y; + T7L = W[36]; + T7N = W[37]; + iio[-WS(ios, 12)] = FMA(T7L, T7M, T7N * T7O); + rio[WS(ios, 19)] = FNMS(T7N, T7M, T7L * T7O); + } + { + E T7S, T7W, T7P, T7T; + T7S = T7Q + T7R; + T7W = T7U + T7V; + T7P = W[52]; + T7T = W[53]; + iio[-WS(ios, 4)] = FMA(T7P, T7S, T7T * T7W); + rio[WS(ios, 27)] = FNMS(T7T, T7S, T7P * T7W); + } + } + { + E T6I, T7k, T79, T7h, T6X, T7g, T72, T7l; + { + E T6A, T6H, T75, T78; + T6A = T6y + T6z; + T6H = T6D + T6G; + T6I = T6A + T6H; + T7k = T6A - T6H; + T75 = T73 + T74; + T78 = T76 + T77; + T79 = T75 + T78; + T7h = T78 - T75; + } + { + E T6P, T6W, T70, T71; + T6P = FNMS(KP195090322, T6O, KP980785280 * T6L); + T6W = FMA(KP980785280, T6S, KP195090322 * T6V); + T6X = T6P + T6W; + T7g = T6W - T6P; + T70 = FMA(KP195090322, T6L, KP980785280 * T6O); + T71 = FNMS(KP195090322, T6S, KP980785280 * T6V); + T72 = T70 + T71; + T7l = T70 - T71; + } + { + E T6Y, T7a, T6x, T6Z; + T6Y = T6I + T6X; + T7a = T72 + T79; + T6x = W[60]; + T6Z = W[61]; + iio[0] = FMA(T6x, T6Y, T6Z * T7a); + rio[WS(ios, 31)] = FNMS(T6Z, T6Y, T6x * T7a); + } + { + E T7o, T7q, T7n, T7p; + T7o = T7k - T7l; + T7q = T7h - T7g; + T7n = W[44]; + T7p = W[45]; + iio[-WS(ios, 8)] = FMA(T7n, T7o, T7p * T7q); + rio[WS(ios, 23)] = FNMS(T7p, T7o, T7n * T7q); + } + { + E T7c, T7e, T7b, T7d; + T7c = T79 - T72; + T7e = T6I - T6X; + T7b = W[28]; + T7d = W[29]; + rio[WS(ios, 15)] = FNMS(T7d, T7e, T7b * T7c); + iio[-WS(ios, 16)] = FMA(T7b, T7e, T7d * T7c); + } + { + E T7i, T7m, T7f, T7j; + T7i = T7g + T7h; + T7m = T7k + T7l; + T7f = W[12]; + T7j = W[13]; + rio[WS(ios, 7)] = FNMS(T7j, T7m, T7f * T7i); + iio[-WS(ios, 24)] = FMA(T7f, T7m, T7j * T7i); + } + } + } + return W; +} + +static const tw_instr twinstr[] = { + {TW_FULL, 0, 32}, + {TW_NEXT, 1, 0} +}; + +static const hc2hc_desc desc = { 32, "hb_32", twinstr, {340, 114, 94, 0}, &GENUS, 0, 0, 0 }; + +void X(codelet_hb_32) (planner *p) { + X(khc2hc_dif_register) (p, hb_32, &desc); +} diff --git a/src/fftw3/rdft/codelets/hc2r/hb_4.c b/src/fftw3/rdft/codelets/hc2r/hb_4.c new file mode 100644 index 0000000..ac05b69 --- /dev/null +++ b/src/fftw3/rdft/codelets/hc2r/hb_4.c @@ -0,0 +1,111 @@ +/* + * Copyright (c) 2003 Matteo Frigo + * Copyright (c) 2003 Massachusetts Institute of Technology + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +/* This file was automatically generated --- DO NOT EDIT */ +/* Generated on Sat Jul 5 22:11:22 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_hc2hc -compact -variables 4 -sign 1 -n 4 -dif -name hb_4 -include hb.h */ + +/* + * This function contains 22 FP additions, 12 FP multiplications, + * (or, 16 additions, 6 multiplications, 6 fused multiply/add), + * 13 stack variables, and 16 memory accesses + */ +/* + * Generator Id's : + * $Id: hb_4.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: hb_4.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: hb_4.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + */ + +#include "hb.h" + +static const R *hb_4(R *rio, R *iio, const R *W, stride ios, int m, int dist) +{ + int i; + for (i = m - 2; i > 0; i = i - 2, rio = rio + dist, iio = iio - dist, W = W + 6) { + E T3, Ti, Tc, Tn, T6, Tm, Tf, Tj; + { + E T1, T2, Ta, Tb; + T1 = rio[0]; + T2 = iio[-WS(ios, 2)]; + T3 = T1 + T2; + Ti = T1 - T2; + Ta = iio[0]; + Tb = rio[WS(ios, 2)]; + Tc = Ta - Tb; + Tn = Ta + Tb; + } + { + E T4, T5, Td, Te; + T4 = rio[WS(ios, 1)]; + T5 = iio[-WS(ios, 3)]; + T6 = T4 + T5; + Tm = T4 - T5; + Td = iio[-WS(ios, 1)]; + Te = rio[WS(ios, 3)]; + Tf = Td - Te; + Tj = Td + Te; + } + rio[0] = T3 + T6; + iio[-WS(ios, 3)] = Tc + Tf; + { + E Tq, Ts, Tp, Tr; + Tq = Tn - Tm; + Ts = Ti + Tj; + Tp = W[4]; + Tr = W[5]; + iio[0] = FMA(Tp, Tq, Tr * Ts); + rio[WS(ios, 3)] = FNMS(Tr, Tq, Tp * Ts); + } + { + E T8, Tg, T7, T9; + T8 = T3 - T6; + Tg = Tc - Tf; + T7 = W[2]; + T9 = W[3]; + rio[WS(ios, 2)] = FNMS(T9, Tg, T7 * T8); + iio[-WS(ios, 1)] = FMA(T9, T8, T7 * Tg); + } + { + E Tk, To, Th, Tl; + Tk = Ti - Tj; + To = Tm + Tn; + Th = W[0]; + Tl = W[1]; + rio[WS(ios, 1)] = FNMS(Tl, To, Th * Tk); + iio[-WS(ios, 2)] = FMA(Th, To, Tl * Tk); + } + } + return W; +} + +static const tw_instr twinstr[] = { + {TW_FULL, 0, 4}, + {TW_NEXT, 1, 0} +}; + +static const hc2hc_desc desc = { 4, "hb_4", twinstr, {16, 6, 6, 0}, &GENUS, 0, 0, 0 }; + +void X(codelet_hb_4) (planner *p) { + X(khc2hc_dif_register) (p, hb_4, &desc); +} diff --git a/src/fftw3/rdft/codelets/hc2r/hb_5.c b/src/fftw3/rdft/codelets/hc2r/hb_5.c new file mode 100644 index 0000000..e0af24d --- /dev/null +++ b/src/fftw3/rdft/codelets/hc2r/hb_5.c @@ -0,0 +1,146 @@ +/* + * Copyright (c) 2003 Matteo Frigo + * Copyright (c) 2003 Massachusetts Institute of Technology + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +/* This file was automatically generated --- DO NOT EDIT */ +/* Generated on Sat Jul 5 22:11:23 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_hc2hc -compact -variables 4 -sign 1 -n 5 -dif -name hb_5 -include hb.h */ + +/* + * This function contains 40 FP additions, 28 FP multiplications, + * (or, 26 additions, 14 multiplications, 14 fused multiply/add), + * 27 stack variables, and 20 memory accesses + */ +/* + * Generator Id's : + * $Id: hb_5.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: hb_5.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: hb_5.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + */ + +#include "hb.h" + +static const R *hb_5(R *rio, R *iio, const R *W, stride ios, int m, int dist) +{ + DK(KP250000000, +0.250000000000000000000000000000000000000000000); + DK(KP587785252, +0.587785252292473129168705954639072768597652438); + DK(KP951056516, +0.951056516295153572116439333379382143405698634); + DK(KP559016994, +0.559016994374947424102293417182819058860154590); + int i; + for (i = m - 2; i > 0; i = i - 2, rio = rio + dist, iio = iio - dist, W = W + 8) { + E T1, Tj, TG, Ts, T8, Ti, T9, Tn, TD, Tu, Tg, Tt; + { + E T7, Tr, T4, Tq; + T1 = rio[0]; + { + E T5, T6, T2, T3; + T5 = rio[WS(ios, 2)]; + T6 = iio[-WS(ios, 3)]; + T7 = T5 + T6; + Tr = T5 - T6; + T2 = rio[WS(ios, 1)]; + T3 = iio[-WS(ios, 4)]; + T4 = T2 + T3; + Tq = T2 - T3; + } + Tj = KP559016994 * (T4 - T7); + TG = FMA(KP951056516, Tq, KP587785252 * Tr); + Ts = FNMS(KP951056516, Tr, KP587785252 * Tq); + T8 = T4 + T7; + Ti = FNMS(KP250000000, T8, T1); + } + { + E Tf, Tm, Tc, Tl; + T9 = iio[0]; + { + E Td, Te, Ta, Tb; + Td = iio[-WS(ios, 2)]; + Te = rio[WS(ios, 3)]; + Tf = Td - Te; + Tm = Td + Te; + Ta = iio[-WS(ios, 1)]; + Tb = rio[WS(ios, 4)]; + Tc = Ta - Tb; + Tl = Ta + Tb; + } + Tn = FNMS(KP951056516, Tm, KP587785252 * Tl); + TD = FMA(KP951056516, Tl, KP587785252 * Tm); + Tu = KP559016994 * (Tc - Tf); + Tg = Tc + Tf; + Tt = FNMS(KP250000000, Tg, T9); + } + rio[0] = T1 + T8; + iio[-WS(ios, 4)] = T9 + Tg; + { + E TE, TM, TI, TK, TC, TH; + TC = Tj + Ti; + TE = TC - TD; + TM = TC + TD; + TH = Tu + Tt; + TI = TG + TH; + TK = TH - TG; + { + E TB, TF, TJ, TL; + TB = W[0]; + TF = W[1]; + rio[WS(ios, 1)] = FNMS(TF, TI, TB * TE); + iio[-WS(ios, 3)] = FMA(TB, TI, TF * TE); + TJ = W[6]; + TL = W[7]; + iio[0] = FMA(TJ, TK, TL * TM); + rio[WS(ios, 4)] = FNMS(TL, TK, TJ * TM); + } + } + { + E To, TA, Tw, Ty, Tk, Tv; + Tk = Ti - Tj; + To = Tk - Tn; + TA = Tk + Tn; + Tv = Tt - Tu; + Tw = Ts + Tv; + Ty = Tv - Ts; + { + E Th, Tp, Tx, Tz; + Th = W[2]; + Tp = W[3]; + rio[WS(ios, 2)] = FNMS(Tp, Tw, Th * To); + iio[-WS(ios, 2)] = FMA(Th, Tw, Tp * To); + Tx = W[4]; + Tz = W[5]; + iio[-WS(ios, 1)] = FMA(Tx, Ty, Tz * TA); + rio[WS(ios, 3)] = FNMS(Tz, Ty, Tx * TA); + } + } + } + return W; +} + +static const tw_instr twinstr[] = { + {TW_FULL, 0, 5}, + {TW_NEXT, 1, 0} +}; + +static const hc2hc_desc desc = { 5, "hb_5", twinstr, {26, 14, 14, 0}, &GENUS, 0, 0, 0 }; + +void X(codelet_hb_5) (planner *p) { + X(khc2hc_dif_register) (p, hb_5, &desc); +} diff --git a/src/fftw3/rdft/codelets/hc2r/hb_6.c b/src/fftw3/rdft/codelets/hc2r/hb_6.c new file mode 100644 index 0000000..1a24696 --- /dev/null +++ b/src/fftw3/rdft/codelets/hc2r/hb_6.c @@ -0,0 +1,160 @@ +/* + * Copyright (c) 2003 Matteo Frigo + * Copyright (c) 2003 Massachusetts Institute of Technology + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +/* This file was automatically generated --- DO NOT EDIT */ +/* Generated on Sat Jul 5 22:11:25 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_hc2hc -compact -variables 4 -sign 1 -n 6 -dif -name hb_6 -include hb.h */ + +/* + * This function contains 46 FP additions, 28 FP multiplications, + * (or, 32 additions, 14 multiplications, 14 fused multiply/add), + * 25 stack variables, and 24 memory accesses + */ +/* + * Generator Id's : + * $Id: hb_6.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: hb_6.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: hb_6.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + */ + +#include "hb.h" + +static const R *hb_6(R *rio, R *iio, const R *W, stride ios, int m, int dist) +{ + DK(KP500000000, +0.500000000000000000000000000000000000000000000); + DK(KP866025403, +0.866025403784438646763723170752936183471402627); + int i; + for (i = m - 2; i > 0; i = i - 2, rio = rio + dist, iio = iio - dist, W = W + 10) { + E T3, Ty, Tp, TE, Ta, TO, Tm, TB, Tj, TL, Tq, TH; + { + E T1, T2, Tn, To; + T1 = rio[0]; + T2 = iio[-WS(ios, 3)]; + T3 = T1 + T2; + Ty = T1 - T2; + Tn = iio[0]; + To = rio[WS(ios, 3)]; + Tp = Tn - To; + TE = Tn + To; + } + { + E T6, Tz, T9, TA; + { + E T4, T5, T7, T8; + T4 = rio[WS(ios, 2)]; + T5 = iio[-WS(ios, 5)]; + T6 = T4 + T5; + Tz = T4 - T5; + T7 = iio[-WS(ios, 4)]; + T8 = rio[WS(ios, 1)]; + T9 = T7 + T8; + TA = T7 - T8; + } + Ta = T6 + T9; + TO = KP866025403 * (Tz - TA); + Tm = KP866025403 * (T6 - T9); + TB = Tz + TA; + } + { + E Tf, TF, Ti, TG; + { + E Td, Te, Tg, Th; + Td = iio[-WS(ios, 1)]; + Te = rio[WS(ios, 4)]; + Tf = Td - Te; + TF = Te + Td; + Tg = iio[-WS(ios, 2)]; + Th = rio[WS(ios, 5)]; + Ti = Tg - Th; + TG = Tg + Th; + } + Tj = KP866025403 * (Tf - Ti); + TL = KP866025403 * (TF + TG); + Tq = Tf + Ti; + TH = TF - TG; + } + rio[0] = T3 + Ta; + iio[-WS(ios, 5)] = Tp + Tq; + { + E TC, TI, Tx, TD; + TC = Ty + TB; + TI = TE - TH; + Tx = W[4]; + TD = W[5]; + rio[WS(ios, 3)] = FNMS(TD, TI, Tx * TC); + iio[-WS(ios, 2)] = FMA(TD, TC, Tx * TI); + } + { + E Tk, Tu, Ts, Tw, Tc, Tr; + Tc = FNMS(KP500000000, Ta, T3); + Tk = Tc + Tj; + Tu = Tc - Tj; + Tr = FNMS(KP500000000, Tq, Tp); + Ts = Tm + Tr; + Tw = Tr - Tm; + { + E Tb, Tl, Tt, Tv; + Tb = W[6]; + Tl = W[7]; + rio[WS(ios, 4)] = FNMS(Tl, Ts, Tb * Tk); + iio[-WS(ios, 1)] = FMA(Tl, Tk, Tb * Ts); + Tt = W[2]; + Tv = W[3]; + rio[WS(ios, 2)] = FNMS(Tv, Tw, Tt * Tu); + iio[-WS(ios, 3)] = FMA(Tv, Tu, Tt * Tw); + } + } + { + E TM, TU, TQ, TS, TK, TP; + TK = FNMS(KP500000000, TB, Ty); + TM = TK - TL; + TU = TK + TL; + TP = FMA(KP500000000, TH, TE); + TQ = TO + TP; + TS = TP - TO; + { + E TJ, TN, TR, TT; + TJ = W[0]; + TN = W[1]; + rio[WS(ios, 1)] = FNMS(TN, TQ, TJ * TM); + iio[-WS(ios, 4)] = FMA(TJ, TQ, TN * TM); + TR = W[8]; + TT = W[9]; + iio[0] = FMA(TR, TS, TT * TU); + rio[WS(ios, 5)] = FNMS(TT, TS, TR * TU); + } + } + } + return W; +} + +static const tw_instr twinstr[] = { + {TW_FULL, 0, 6}, + {TW_NEXT, 1, 0} +}; + +static const hc2hc_desc desc = { 6, "hb_6", twinstr, {32, 14, 14, 0}, &GENUS, 0, 0, 0 }; + +void X(codelet_hb_6) (planner *p) { + X(khc2hc_dif_register) (p, hb_6, &desc); +} diff --git a/src/fftw3/rdft/codelets/hc2r/hb_64.c b/src/fftw3/rdft/codelets/hc2r/hb_64.c new file mode 100644 index 0000000..d3f9afc --- /dev/null +++ b/src/fftw3/rdft/codelets/hc2r/hb_64.c @@ -0,0 +1,1972 @@ +/* + * Copyright (c) 2003 Matteo Frigo + * Copyright (c) 2003 Massachusetts Institute of Technology + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +/* This file was automatically generated --- DO NOT EDIT */ +/* Generated on Sat Jul 5 22:11:42 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_hc2hc -compact -variables 4 -sign 1 -n 64 -dif -name hb_64 -include hb.h */ + +/* + * This function contains 1038 FP additions, 500 FP multiplications, + * (or, 808 additions, 270 multiplications, 230 fused multiply/add), + * 196 stack variables, and 256 memory accesses + */ +/* + * Generator Id's : + * $Id: hb_64.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: hb_64.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: hb_64.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + */ + +#include "hb.h" + +static const R *hb_64(R *rio, R *iio, const R *W, stride ios, int m, int dist) +{ + DK(KP634393284, +0.634393284163645498215171613225493370675687095); + DK(KP773010453, +0.773010453362736960810906609758469800971041293); + DK(KP098017140, +0.098017140329560601994195563888641845861136673); + DK(KP995184726, +0.995184726672196886244836953109479921575474869); + DK(KP471396736, +0.471396736825997648556387625905254377657460319); + DK(KP881921264, +0.881921264348355029712756863660388349508442621); + DK(KP290284677, +0.290284677254462367636192375817395274691476278); + DK(KP956940335, +0.956940335732208864935797886980269969482849206); + DK(KP195090322, +0.195090322016128267848284868477022240927691618); + DK(KP980785280, +0.980785280403230449126182236134239036973933731); + DK(KP555570233, +0.555570233019602224742830813948532874374937191); + DK(KP831469612, +0.831469612302545237078788377617905756738560812); + DK(KP382683432, +0.382683432365089771728459984030398866761344562); + DK(KP923879532, +0.923879532511286756128183189396788286822416626); + DK(KP707106781, +0.707106781186547524400844362104849039284835938); + int i; + for (i = m - 2; i > 0; i = i - 2, rio = rio + dist, iio = iio - dist, W = W + 126) { + E Tf, T7i, Tfa, ThM, Tgp, ThH, T2c, T5O, T4T, T6n, Tcp, Ted, TcA, TdE, T87; + E T9o, TK, T93, T2P, T4F, Tfo, Thz, T5T, T6j, Tbx, TdI, Tfl, ThA, T7r, T81; + E TbE, TdH, TZ, T94, T38, T4G, Tfv, ThC, T5W, T6k, TbQ, TdK, Tfs, ThD, T7w; + E T82, TbX, TdL, Tu, T84, Tfh, ThG, Tgm, ThN, T2v, T6m, T4K, T5P, Tce, TdF; + E TcD, Tec, T7l, T9p, T1L, T20, T9c, T9d, T9e, T9f, T40, T66, Tg1, Thu, Tg8; + E Thv, Tg5, Thr, T4n, T67, T4j, T69, T4w, T6a, TaT, TdW, Tb8, TdZ, TfU, Ths; + E T7O, T8y, T7T, T8z, Tbc, TdX, Tbj, Te0, T1g, T1v, T97, T98, T99, T9a, T3j; + E T5Z, TfI, Thk, TfP, Thl, TfM, Tho, T3G, T60, T3C, T62, T3P, T63, Tak, TdQ; + E Tav, TdT, TfB, Thn, T7D, T8v, T7I, T8w, TaD, TdP, TaG, TdS; + { + E T3, Tcm, T4O, Tcv, T6, Tcu, T4R, Tcn, Td, Tcy, T2a, Tch, Ta, Tcx, T27; + E Tck; + { + E T1, T2, T4P, T4Q; + T1 = rio[0]; + T2 = iio[-WS(ios, 32)]; + T3 = T1 + T2; + Tcm = T1 - T2; + { + E T4M, T4N, T4, T5; + T4M = iio[0]; + T4N = rio[WS(ios, 32)]; + T4O = T4M - T4N; + Tcv = T4M + T4N; + T4 = rio[WS(ios, 16)]; + T5 = iio[-WS(ios, 48)]; + T6 = T4 + T5; + Tcu = T4 - T5; + } + T4P = iio[-WS(ios, 16)]; + T4Q = rio[WS(ios, 48)]; + T4R = T4P - T4Q; + Tcn = T4P + T4Q; + { + E Tb, Tc, Tcf, T28, T29, Tcg; + Tb = iio[-WS(ios, 56)]; + Tc = rio[WS(ios, 24)]; + Tcf = Tb - Tc; + T28 = iio[-WS(ios, 24)]; + T29 = rio[WS(ios, 56)]; + Tcg = T29 + T28; + Td = Tb + Tc; + Tcy = Tcf + Tcg; + T2a = T28 - T29; + Tch = Tcf - Tcg; + } + { + E T8, T9, Tcj, T25, T26, Tci; + T8 = rio[WS(ios, 8)]; + T9 = iio[-WS(ios, 40)]; + Tcj = T8 - T9; + T25 = iio[-WS(ios, 8)]; + T26 = rio[WS(ios, 40)]; + Tci = T25 + T26; + Ta = T8 + T9; + Tcx = Tcj + Tci; + T27 = T25 - T26; + Tck = Tci - Tcj; + } + } + { + E T7, Te, Tf8, Tf9; + T7 = T3 + T6; + Te = Ta + Td; + Tf = T7 + Te; + T7i = T7 - Te; + Tf8 = Tcv - Tcu; + Tf9 = KP707106781 * (Tck + Tch); + Tfa = Tf8 + Tf9; + ThM = Tf8 - Tf9; + } + { + E Tgn, Tgo, T24, T2b; + Tgn = KP707106781 * (Tcx + Tcy); + Tgo = Tcm + Tcn; + Tgp = Tgn + Tgo; + ThH = Tgo - Tgn; + T24 = T3 - T6; + T2b = T27 - T2a; + T2c = T24 + T2b; + T5O = T24 - T2b; + } + { + E T4L, T4S, Tcl, Tco; + T4L = Td - Ta; + T4S = T4O - T4R; + T4T = T4L + T4S; + T6n = T4S - T4L; + Tcl = KP707106781 * (Tch - Tck); + Tco = Tcm - Tcn; + Tcp = Tcl + Tco; + Ted = Tco - Tcl; + } + { + E Tcw, Tcz, T85, T86; + Tcw = Tcu + Tcv; + Tcz = KP707106781 * (Tcx - Tcy); + TcA = Tcw + Tcz; + TdE = Tcw - Tcz; + T85 = T4O + T4R; + T86 = T27 + T2a; + T87 = T85 - T86; + T9o = T86 + T85; + } + } + { + E TC, Tby, T2x, Tbu, T2N, Tbz, T7o, Tbv, TJ, TbB, TbC, T2E, T2G, Tbp, Tbs; + E T7p, Tfj, Tfk; + { + E Tw, Tx, Ty, Tz, TA, TB; + Tw = rio[WS(ios, 2)]; + Tx = iio[-WS(ios, 34)]; + Ty = Tw + Tx; + Tz = rio[WS(ios, 18)]; + TA = iio[-WS(ios, 50)]; + TB = Tz + TA; + TC = Ty + TB; + Tby = Tz - TA; + T2x = Ty - TB; + Tbu = Tw - Tx; + } + { + E T2H, T2I, T2J, T2K, T2L, T2M; + T2H = iio[-WS(ios, 2)]; + T2I = rio[WS(ios, 34)]; + T2J = T2H - T2I; + T2K = iio[-WS(ios, 18)]; + T2L = rio[WS(ios, 50)]; + T2M = T2K - T2L; + T2N = T2J - T2M; + Tbz = T2H + T2I; + T7o = T2J + T2M; + Tbv = T2K + T2L; + } + { + E TF, Tbr, T2A, Tbq, TI, Tbn, T2D, Tbo; + { + E TD, TE, T2y, T2z; + TD = rio[WS(ios, 10)]; + TE = iio[-WS(ios, 42)]; + TF = TD + TE; + Tbr = TD - TE; + T2y = iio[-WS(ios, 10)]; + T2z = rio[WS(ios, 42)]; + T2A = T2y - T2z; + Tbq = T2y + T2z; + } + { + E TG, TH, T2B, T2C; + TG = iio[-WS(ios, 58)]; + TH = rio[WS(ios, 26)]; + TI = TG + TH; + Tbn = TG - TH; + T2B = iio[-WS(ios, 26)]; + T2C = rio[WS(ios, 58)]; + T2D = T2B - T2C; + Tbo = T2C + T2B; + } + TJ = TF + TI; + TbB = Tbr + Tbq; + TbC = Tbn + Tbo; + T2E = T2A - T2D; + T2G = TI - TF; + Tbp = Tbn - Tbo; + Tbs = Tbq - Tbr; + T7p = T2A + T2D; + } + TK = TC + TJ; + T93 = T7p + T7o; + { + E T2F, T2O, Tfm, Tfn; + T2F = T2x + T2E; + T2O = T2G + T2N; + T2P = FMA(KP923879532, T2F, KP382683432 * T2O); + T4F = FNMS(KP382683432, T2F, KP923879532 * T2O); + Tfm = KP707106781 * (TbB + TbC); + Tfn = Tbu + Tbv; + Tfo = Tfm + Tfn; + Thz = Tfn - Tfm; + } + { + E T5R, T5S, Tbt, Tbw; + T5R = T2x - T2E; + T5S = T2N - T2G; + T5T = FNMS(KP382683432, T5S, KP923879532 * T5R); + T6j = FMA(KP382683432, T5R, KP923879532 * T5S); + Tbt = KP707106781 * (Tbp - Tbs); + Tbw = Tbu - Tbv; + Tbx = Tbt + Tbw; + TdI = Tbw - Tbt; + } + Tfj = Tbz - Tby; + Tfk = KP707106781 * (Tbs + Tbp); + Tfl = Tfj + Tfk; + ThA = Tfj - Tfk; + { + E T7n, T7q, TbA, TbD; + T7n = TC - TJ; + T7q = T7o - T7p; + T7r = T7n + T7q; + T81 = T7q - T7n; + TbA = Tby + Tbz; + TbD = KP707106781 * (TbB - TbC); + TbE = TbA + TbD; + TdH = TbA - TbD; + } + } + { + E TR, TbU, T2Q, TbN, T36, TbV, T7t, TbO, TY, TbR, TbS, T2X, T2Z, TbI, TbL; + E T7u, Tfq, Tfr; + { + E TL, TM, TN, TO, TP, TQ; + TL = iio[-WS(ios, 62)]; + TM = rio[WS(ios, 30)]; + TN = TL + TM; + TO = rio[WS(ios, 14)]; + TP = iio[-WS(ios, 46)]; + TQ = TO + TP; + TR = TN + TQ; + TbU = TL - TM; + T2Q = TN - TQ; + TbN = TO - TP; + } + { + E T30, T31, T32, T33, T34, T35; + T30 = iio[-WS(ios, 30)]; + T31 = rio[WS(ios, 62)]; + T32 = T30 - T31; + T33 = iio[-WS(ios, 14)]; + T34 = rio[WS(ios, 46)]; + T35 = T33 - T34; + T36 = T32 - T35; + TbV = T33 + T34; + T7t = T32 + T35; + TbO = T31 + T30; + } + { + E TU, TbG, T2T, TbH, TX, TbJ, T2W, TbK; + { + E TS, TT, T2R, T2S; + TS = rio[WS(ios, 6)]; + TT = iio[-WS(ios, 38)]; + TU = TS + TT; + TbG = TS - TT; + T2R = iio[-WS(ios, 6)]; + T2S = rio[WS(ios, 38)]; + T2T = T2R - T2S; + TbH = T2R + T2S; + } + { + E TV, TW, T2U, T2V; + TV = iio[-WS(ios, 54)]; + TW = rio[WS(ios, 22)]; + TX = TV + TW; + TbJ = TV - TW; + T2U = iio[-WS(ios, 22)]; + T2V = rio[WS(ios, 54)]; + T2W = T2U - T2V; + TbK = T2V + T2U; + } + TY = TU + TX; + TbR = TbJ - TbK; + TbS = TbH - TbG; + T2X = T2T - T2W; + T2Z = TX - TU; + TbI = TbG + TbH; + TbL = TbJ + TbK; + T7u = T2T + T2W; + } + TZ = TR + TY; + T94 = T7u + T7t; + { + E T2Y, T37, Tft, Tfu; + T2Y = T2Q + T2X; + T37 = T2Z + T36; + T38 = FNMS(KP382683432, T37, KP923879532 * T2Y); + T4G = FMA(KP382683432, T2Y, KP923879532 * T37); + Tft = KP707106781 * (TbI + TbL); + Tfu = TbU + TbV; + Tfv = Tft + Tfu; + ThC = Tfu - Tft; + } + { + E T5U, T5V, TbM, TbP; + T5U = T2Q - T2X; + T5V = T36 - T2Z; + T5W = FMA(KP923879532, T5U, KP382683432 * T5V); + T6k = FNMS(KP382683432, T5U, KP923879532 * T5V); + TbM = KP707106781 * (TbI - TbL); + TbP = TbN - TbO; + TbQ = TbM + TbP; + TdK = TbP - TbM; + } + Tfq = KP707106781 * (TbS + TbR); + Tfr = TbN + TbO; + Tfs = Tfq - Tfr; + ThD = Tfq + Tfr; + { + E T7s, T7v, TbT, TbW; + T7s = TR - TY; + T7v = T7t - T7u; + T7w = T7s - T7v; + T82 = T7s + T7v; + TbT = KP707106781 * (TbR - TbS); + TbW = TbU - TbV; + TbX = TbT + TbW; + TdL = TbW - TbT; + } + } + { + E Ti, T2g, Tl, T2j, T2d, T2k, Tfc, Tfb, Tc5, Tc2, Tp, T2p, Ts, T2s, T2m; + E T2t, Tff, Tfe, Tcc, Tc9; + { + E Tc0, Tc4, Tc3, Tc1; + { + E Tg, Th, T2e, T2f; + Tg = rio[WS(ios, 4)]; + Th = iio[-WS(ios, 36)]; + Ti = Tg + Th; + Tc0 = Tg - Th; + T2e = iio[-WS(ios, 4)]; + T2f = rio[WS(ios, 36)]; + T2g = T2e - T2f; + Tc4 = T2e + T2f; + } + { + E Tj, Tk, T2h, T2i; + Tj = rio[WS(ios, 20)]; + Tk = iio[-WS(ios, 52)]; + Tl = Tj + Tk; + Tc3 = Tj - Tk; + T2h = iio[-WS(ios, 20)]; + T2i = rio[WS(ios, 52)]; + T2j = T2h - T2i; + Tc1 = T2h + T2i; + } + T2d = Ti - Tl; + T2k = T2g - T2j; + Tfc = Tc0 + Tc1; + Tfb = Tc4 - Tc3; + Tc5 = Tc3 + Tc4; + Tc2 = Tc0 - Tc1; + } + { + E Tc7, Tcb, Tca, Tc8; + { + E Tn, To, T2n, T2o; + Tn = iio[-WS(ios, 60)]; + To = rio[WS(ios, 28)]; + Tp = Tn + To; + Tc7 = Tn - To; + T2n = iio[-WS(ios, 28)]; + T2o = rio[WS(ios, 60)]; + T2p = T2n - T2o; + Tcb = T2o + T2n; + } + { + E Tq, Tr, T2q, T2r; + Tq = rio[WS(ios, 12)]; + Tr = iio[-WS(ios, 44)]; + Ts = Tq + Tr; + Tca = Tq - Tr; + T2q = iio[-WS(ios, 12)]; + T2r = rio[WS(ios, 44)]; + T2s = T2q - T2r; + Tc8 = T2q + T2r; + } + T2m = Tp - Ts; + T2t = T2p - T2s; + Tff = Tca + Tcb; + Tfe = Tc7 + Tc8; + Tcc = Tca - Tcb; + Tc9 = Tc7 - Tc8; + } + { + E Tm, Tt, Tfd, Tfg; + Tm = Ti + Tl; + Tt = Tp + Ts; + Tu = Tm + Tt; + T84 = Tt - Tm; + Tfd = FNMS(KP382683432, Tfc, KP923879532 * Tfb); + Tfg = FNMS(KP923879532, Tff, KP382683432 * Tfe); + Tfh = Tfd + Tfg; + ThG = Tfg - Tfd; + } + { + E Tgk, Tgl, T2l, T2u; + Tgk = FMA(KP382683432, Tfb, KP923879532 * Tfc); + Tgl = FMA(KP923879532, Tfe, KP382683432 * Tff); + Tgm = Tgk + Tgl; + ThN = Tgk - Tgl; + T2l = T2d + T2k; + T2u = T2m - T2t; + T2v = KP707106781 * (T2l + T2u); + T6m = KP707106781 * (T2l - T2u); + } + { + E T4I, T4J, Tc6, Tcd; + T4I = T2k - T2d; + T4J = T2m + T2t; + T4K = KP707106781 * (T4I + T4J); + T5P = KP707106781 * (T4J - T4I); + Tc6 = FNMS(KP382683432, Tc5, KP923879532 * Tc2); + Tcd = FMA(KP923879532, Tc9, KP382683432 * Tcc); + Tce = Tc6 + Tcd; + TdF = Tcd - Tc6; + } + { + E TcB, TcC, T7j, T7k; + TcB = FMA(KP923879532, Tc5, KP382683432 * Tc2); + TcC = FNMS(KP382683432, Tc9, KP923879532 * Tcc); + TcD = TcB + TcC; + Tec = TcB - TcC; + T7j = T2g + T2j; + T7k = T2s + T2p; + T7l = T7j - T7k; + T9p = T7j + T7k; + } + } + { + E T1z, T1C, T1D, Tbg, TaQ, T4r, T4u, T7Q, Tbh, TaR, T1G, T3V, T1J, T3Y, T1K; + E T7R, Tbe, Tbd, TaO, TaL, T1S, TfV, TfW, T41, T48, TaW, TaZ, T7L, T1Z, TfY; + E TfZ, T4a, T4h, Tb3, Tb6, T7M; + { + E T1x, T1y, T1A, T1B; + T1x = iio[-WS(ios, 63)]; + T1y = rio[WS(ios, 31)]; + T1z = T1x + T1y; + T1A = rio[WS(ios, 15)]; + T1B = iio[-WS(ios, 47)]; + T1C = T1A + T1B; + T1D = T1z + T1C; + Tbg = T1x - T1y; + TaQ = T1A - T1B; + } + { + E T4p, T4q, T4s, T4t; + T4p = iio[-WS(ios, 31)]; + T4q = rio[WS(ios, 63)]; + T4r = T4p - T4q; + T4s = iio[-WS(ios, 15)]; + T4t = rio[WS(ios, 47)]; + T4u = T4s - T4t; + T7Q = T4r + T4u; + Tbh = T4s + T4t; + TaR = T4q + T4p; + } + { + E TaJ, TaK, TaM, TaN; + { + E T1E, T1F, T3T, T3U; + T1E = rio[WS(ios, 7)]; + T1F = iio[-WS(ios, 39)]; + T1G = T1E + T1F; + TaJ = T1E - T1F; + T3T = iio[-WS(ios, 7)]; + T3U = rio[WS(ios, 39)]; + T3V = T3T - T3U; + TaK = T3T + T3U; + } + { + E T1H, T1I, T3W, T3X; + T1H = iio[-WS(ios, 55)]; + T1I = rio[WS(ios, 23)]; + T1J = T1H + T1I; + TaM = T1H - T1I; + T3W = iio[-WS(ios, 23)]; + T3X = rio[WS(ios, 55)]; + T3Y = T3W - T3X; + TaN = T3X + T3W; + } + T1K = T1G + T1J; + T7R = T3V + T3Y; + Tbe = TaK - TaJ; + Tbd = TaM - TaN; + TaO = TaM + TaN; + TaL = TaJ + TaK; + } + { + E T1O, TaX, T44, TaV, T1R, TaU, T47, TaY; + { + E T1M, T1N, T42, T43; + T1M = rio[WS(ios, 3)]; + T1N = iio[-WS(ios, 35)]; + T1O = T1M + T1N; + TaX = T1M - T1N; + T42 = iio[-WS(ios, 3)]; + T43 = rio[WS(ios, 35)]; + T44 = T42 - T43; + TaV = T42 + T43; + } + { + E T1P, T1Q, T45, T46; + T1P = rio[WS(ios, 19)]; + T1Q = iio[-WS(ios, 51)]; + T1R = T1P + T1Q; + TaU = T1P - T1Q; + T45 = iio[-WS(ios, 19)]; + T46 = rio[WS(ios, 51)]; + T47 = T45 - T46; + TaY = T45 + T46; + } + T1S = T1O + T1R; + TfV = TaV - TaU; + TfW = TaX + TaY; + T41 = T1O - T1R; + T48 = T44 - T47; + TaW = TaU + TaV; + TaZ = TaX - TaY; + T7L = T44 + T47; + } + { + E T1V, Tb4, T4d, Tb2, T1Y, Tb1, T4g, Tb5; + { + E T1T, T1U, T4b, T4c; + T1T = iio[-WS(ios, 59)]; + T1U = rio[WS(ios, 27)]; + T1V = T1T + T1U; + Tb4 = T1T - T1U; + T4b = iio[-WS(ios, 27)]; + T4c = rio[WS(ios, 59)]; + T4d = T4b - T4c; + Tb2 = T4c + T4b; + } + { + E T1W, T1X, T4e, T4f; + T1W = rio[WS(ios, 11)]; + T1X = iio[-WS(ios, 43)]; + T1Y = T1W + T1X; + Tb1 = T1W - T1X; + T4e = iio[-WS(ios, 11)]; + T4f = rio[WS(ios, 43)]; + T4g = T4e - T4f; + Tb5 = T4e + T4f; + } + T1Z = T1V + T1Y; + TfY = Tb4 + Tb5; + TfZ = Tb1 + Tb2; + T4a = T1V - T1Y; + T4h = T4d - T4g; + Tb3 = Tb1 - Tb2; + Tb6 = Tb4 - Tb5; + T7M = T4g + T4d; + } + T1L = T1D + T1K; + T20 = T1S + T1Z; + T9c = T1L - T20; + T9d = T7R + T7Q; + T9e = T7L + T7M; + T9f = T9d - T9e; + { + E T3S, T3Z, TfX, Tg0; + T3S = T1z - T1C; + T3Z = T3V - T3Y; + T40 = T3S + T3Z; + T66 = T3S - T3Z; + TfX = FNMS(KP382683432, TfW, KP923879532 * TfV); + Tg0 = FNMS(KP923879532, TfZ, KP382683432 * TfY); + Tg1 = TfX + Tg0; + Thu = Tg0 - TfX; + } + { + E Tg6, Tg7, Tg3, Tg4; + Tg6 = KP707106781 * (TaL + TaO); + Tg7 = Tbg + Tbh; + Tg8 = Tg6 + Tg7; + Thv = Tg7 - Tg6; + Tg3 = FMA(KP382683432, TfV, KP923879532 * TfW); + Tg4 = FMA(KP923879532, TfY, KP382683432 * TfZ); + Tg5 = Tg3 + Tg4; + Thr = Tg3 - Tg4; + } + { + E T4l, T4m, T49, T4i; + T4l = T48 - T41; + T4m = T4a + T4h; + T4n = KP707106781 * (T4l + T4m); + T67 = KP707106781 * (T4m - T4l); + T49 = T41 + T48; + T4i = T4a - T4h; + T4j = KP707106781 * (T49 + T4i); + T69 = KP707106781 * (T49 - T4i); + } + { + E T4o, T4v, TaP, TaS; + T4o = T1J - T1G; + T4v = T4r - T4u; + T4w = T4o + T4v; + T6a = T4v - T4o; + TaP = KP707106781 * (TaL - TaO); + TaS = TaQ - TaR; + TaT = TaP + TaS; + TdW = TaS - TaP; + } + { + E Tb0, Tb7, TfS, TfT; + Tb0 = FMA(KP923879532, TaW, KP382683432 * TaZ); + Tb7 = FNMS(KP382683432, Tb6, KP923879532 * Tb3); + Tb8 = Tb0 + Tb7; + TdZ = Tb0 - Tb7; + TfS = KP707106781 * (Tbe + Tbd); + TfT = TaQ + TaR; + TfU = TfS - TfT; + Ths = TfS + TfT; + } + { + E T7K, T7N, T7P, T7S; + T7K = T1D - T1K; + T7N = T7L - T7M; + T7O = T7K + T7N; + T8y = T7K - T7N; + T7P = T1Z - T1S; + T7S = T7Q - T7R; + T7T = T7P + T7S; + T8z = T7S - T7P; + } + { + E Tba, Tbb, Tbf, Tbi; + Tba = FNMS(KP382683432, TaW, KP923879532 * TaZ); + Tbb = FMA(KP923879532, Tb6, KP382683432 * Tb3); + Tbc = Tba + Tbb; + TdX = Tbb - Tba; + Tbf = KP707106781 * (Tbd - Tbe); + Tbi = Tbg - Tbh; + Tbj = Tbf + Tbi; + Te0 = Tbi - Tbf; + } + } + { + E T14, T17, T18, Tax, Tas, T3K, T3N, T7F, Tay, Tat, T1b, T3e, T1e, T3h, T1f; + E T7G, TaB, TaA, Taq, Tan, T1n, TfC, TfD, T3k, T3r, Ta8, Tab, T7A, T1u, TfF; + E TfG, T3t, T3A, Taf, Tai, T7B; + { + E T12, T13, T15, T16; + T12 = rio[WS(ios, 1)]; + T13 = iio[-WS(ios, 33)]; + T14 = T12 + T13; + T15 = rio[WS(ios, 17)]; + T16 = iio[-WS(ios, 49)]; + T17 = T15 + T16; + T18 = T14 + T17; + Tax = T15 - T16; + Tas = T12 - T13; + } + { + E T3I, T3J, T3L, T3M; + T3I = iio[-WS(ios, 1)]; + T3J = rio[WS(ios, 33)]; + T3K = T3I - T3J; + T3L = iio[-WS(ios, 17)]; + T3M = rio[WS(ios, 49)]; + T3N = T3L - T3M; + T7F = T3K + T3N; + Tay = T3I + T3J; + Tat = T3L + T3M; + } + { + E Tap, Tao, Tal, Tam; + { + E T19, T1a, T3c, T3d; + T19 = rio[WS(ios, 9)]; + T1a = iio[-WS(ios, 41)]; + T1b = T19 + T1a; + Tap = T19 - T1a; + T3c = iio[-WS(ios, 9)]; + T3d = rio[WS(ios, 41)]; + T3e = T3c - T3d; + Tao = T3c + T3d; + } + { + E T1c, T1d, T3f, T3g; + T1c = iio[-WS(ios, 57)]; + T1d = rio[WS(ios, 25)]; + T1e = T1c + T1d; + Tal = T1c - T1d; + T3f = iio[-WS(ios, 25)]; + T3g = rio[WS(ios, 57)]; + T3h = T3f - T3g; + Tam = T3g + T3f; + } + T1f = T1b + T1e; + T7G = T3e + T3h; + TaB = Tal + Tam; + TaA = Tap + Tao; + Taq = Tao - Tap; + Tan = Tal - Tam; + } + { + E T1j, Ta6, T3n, Taa, T1m, Ta9, T3q, Ta7; + { + E T1h, T1i, T3l, T3m; + T1h = rio[WS(ios, 5)]; + T1i = iio[-WS(ios, 37)]; + T1j = T1h + T1i; + Ta6 = T1h - T1i; + T3l = iio[-WS(ios, 5)]; + T3m = rio[WS(ios, 37)]; + T3n = T3l - T3m; + Taa = T3l + T3m; + } + { + E T1k, T1l, T3o, T3p; + T1k = rio[WS(ios, 21)]; + T1l = iio[-WS(ios, 53)]; + T1m = T1k + T1l; + Ta9 = T1k - T1l; + T3o = iio[-WS(ios, 21)]; + T3p = rio[WS(ios, 53)]; + T3q = T3o - T3p; + Ta7 = T3o + T3p; + } + T1n = T1j + T1m; + TfC = Taa - Ta9; + TfD = Ta6 + Ta7; + T3k = T1j - T1m; + T3r = T3n - T3q; + Ta8 = Ta6 - Ta7; + Tab = Ta9 + Taa; + T7A = T3n + T3q; + } + { + E T1q, Tad, T3w, Tah, T1t, Tag, T3z, Tae; + { + E T1o, T1p, T3u, T3v; + T1o = iio[-WS(ios, 61)]; + T1p = rio[WS(ios, 29)]; + T1q = T1o + T1p; + Tad = T1o - T1p; + T3u = iio[-WS(ios, 29)]; + T3v = rio[WS(ios, 61)]; + T3w = T3u - T3v; + Tah = T3v + T3u; + } + { + E T1r, T1s, T3x, T3y; + T1r = rio[WS(ios, 13)]; + T1s = iio[-WS(ios, 45)]; + T1t = T1r + T1s; + Tag = T1r - T1s; + T3x = iio[-WS(ios, 13)]; + T3y = rio[WS(ios, 45)]; + T3z = T3x - T3y; + Tae = T3x + T3y; + } + T1u = T1q + T1t; + TfF = Tad + Tae; + TfG = Tag + Tah; + T3t = T1q - T1t; + T3A = T3w - T3z; + Taf = Tad - Tae; + Tai = Tag - Tah; + T7B = T3z + T3w; + } + T1g = T18 + T1f; + T1v = T1n + T1u; + T97 = T1g - T1v; + T98 = T7G + T7F; + T99 = T7A + T7B; + T9a = T98 - T99; + { + E T3b, T3i, TfE, TfH; + T3b = T14 - T17; + T3i = T3e - T3h; + T3j = T3b + T3i; + T5Z = T3b - T3i; + TfE = FNMS(KP382683432, TfD, KP923879532 * TfC); + TfH = FNMS(KP923879532, TfG, KP382683432 * TfF); + TfI = TfE + TfH; + Thk = TfH - TfE; + } + { + E TfN, TfO, TfK, TfL; + TfN = KP707106781 * (TaA + TaB); + TfO = Tas + Tat; + TfP = TfN + TfO; + Thl = TfO - TfN; + TfK = FMA(KP382683432, TfC, KP923879532 * TfD); + TfL = FMA(KP923879532, TfF, KP382683432 * TfG); + TfM = TfK + TfL; + Tho = TfK - TfL; + } + { + E T3E, T3F, T3s, T3B; + T3E = T3r - T3k; + T3F = T3t + T3A; + T3G = KP707106781 * (T3E + T3F); + T60 = KP707106781 * (T3F - T3E); + T3s = T3k + T3r; + T3B = T3t - T3A; + T3C = KP707106781 * (T3s + T3B); + T62 = KP707106781 * (T3s - T3B); + } + { + E T3H, T3O, Tac, Taj; + T3H = T1e - T1b; + T3O = T3K - T3N; + T3P = T3H + T3O; + T63 = T3O - T3H; + Tac = FNMS(KP382683432, Tab, KP923879532 * Ta8); + Taj = FMA(KP923879532, Taf, KP382683432 * Tai); + Tak = Tac + Taj; + TdQ = Taj - Tac; + } + { + E Tar, Tau, Tfz, TfA; + Tar = KP707106781 * (Tan - Taq); + Tau = Tas - Tat; + Tav = Tar + Tau; + TdT = Tau - Tar; + Tfz = Tay - Tax; + TfA = KP707106781 * (Taq + Tan); + TfB = Tfz + TfA; + Thn = Tfz - TfA; + } + { + E T7z, T7C, T7E, T7H; + T7z = T18 - T1f; + T7C = T7A - T7B; + T7D = T7z + T7C; + T8v = T7z - T7C; + T7E = T1u - T1n; + T7H = T7F - T7G; + T7I = T7E + T7H; + T8w = T7H - T7E; + } + { + E Taz, TaC, TaE, TaF; + Taz = Tax + Tay; + TaC = KP707106781 * (TaA - TaB); + TaD = Taz + TaC; + TdP = Taz - TaC; + TaE = FMA(KP923879532, Tab, KP382683432 * Ta8); + TaF = FNMS(KP382683432, Taf, KP923879532 * Tai); + TaG = TaE + TaF; + TdS = TaE - TaF; + } + } + { + E T11, T9K, T9T, Ta2, T22, T9Q, T9N, Ta3; + { + E Tv, T10, T9R, T9S; + Tv = Tf + Tu; + T10 = TK + TZ; + T11 = Tv + T10; + T9K = Tv - T10; + T9R = T9p + T9o; + T9S = T93 + T94; + T9T = T9R - T9S; + Ta2 = T9S + T9R; + } + { + E T1w, T21, T9L, T9M; + T1w = T1g + T1v; + T21 = T1L + T20; + T22 = T1w + T21; + T9Q = T21 - T1w; + T9L = T99 + T98; + T9M = T9e + T9d; + T9N = T9L - T9M; + Ta3 = T9L + T9M; + } + rio[0] = T11 + T22; + iio[-WS(ios, 63)] = Ta3 + Ta2; + { + E T9O, T9U, T9J, T9P; + T9O = T9K + T9N; + T9U = T9Q + T9T; + T9J = W[94]; + T9P = W[95]; + rio[WS(ios, 48)] = FNMS(T9P, T9U, T9J * T9O); + iio[-WS(ios, 15)] = FMA(T9P, T9O, T9J * T9U); + } + { + E T9W, T9Y, T9V, T9X; + T9W = T9K - T9N; + T9Y = T9T - T9Q; + T9V = W[30]; + T9X = W[31]; + rio[WS(ios, 16)] = FNMS(T9X, T9Y, T9V * T9W); + iio[-WS(ios, 47)] = FMA(T9X, T9W, T9V * T9Y); + } + { + E Ta0, Ta4, T9Z, Ta1; + Ta0 = T11 - T22; + Ta4 = Ta2 - Ta3; + T9Z = W[62]; + Ta1 = W[63]; + rio[WS(ios, 32)] = FNMS(Ta1, Ta4, T9Z * Ta0); + iio[-WS(ios, 31)] = FMA(Ta1, Ta0, T9Z * Ta4); + } + } + { + E T96, T9y, T9r, T9D, T9h, T9C, T9m, T9z; + { + E T92, T95, T9n, T9q; + T92 = Tf - Tu; + T95 = T93 - T94; + T96 = T92 + T95; + T9y = T92 - T95; + T9n = TZ - TK; + T9q = T9o - T9p; + T9r = T9n + T9q; + T9D = T9q - T9n; + } + { + E T9b, T9g, T9k, T9l; + T9b = T97 + T9a; + T9g = T9c - T9f; + T9h = KP707106781 * (T9b + T9g); + T9C = KP707106781 * (T9b - T9g); + T9k = T9a - T97; + T9l = T9c + T9f; + T9m = KP707106781 * (T9k + T9l); + T9z = KP707106781 * (T9l - T9k); + } + { + E T9i, T9s, T91, T9j; + T9i = T96 + T9h; + T9s = T9m + T9r; + T91 = W[110]; + T9j = W[111]; + rio[WS(ios, 56)] = FNMS(T9j, T9s, T91 * T9i); + iio[-WS(ios, 7)] = FMA(T9j, T9i, T91 * T9s); + } + { + E T9G, T9I, T9F, T9H; + T9G = T9y - T9z; + T9I = T9D - T9C; + T9F = W[78]; + T9H = W[79]; + rio[WS(ios, 40)] = FNMS(T9H, T9I, T9F * T9G); + iio[-WS(ios, 23)] = FMA(T9H, T9G, T9F * T9I); + } + { + E T9u, T9w, T9t, T9v; + T9u = T96 - T9h; + T9w = T9r - T9m; + T9t = W[46]; + T9v = W[47]; + rio[WS(ios, 24)] = FNMS(T9v, T9w, T9t * T9u); + iio[-WS(ios, 39)] = FMA(T9v, T9u, T9t * T9w); + } + { + E T9A, T9E, T9x, T9B; + T9A = T9y + T9z; + T9E = T9C + T9D; + T9x = W[14]; + T9B = W[15]; + rio[WS(ios, 8)] = FNMS(T9B, T9E, T9x * T9A); + iio[-WS(ios, 55)] = FMA(T9B, T9A, T9x * T9E); + } + } + { + E T8u, T8Q, T8J, T8V, T8B, T8U, T8G, T8R; + { + E T8s, T8t, T8H, T8I; + T8s = T7i - T7l; + T8t = KP707106781 * (T82 - T81); + T8u = T8s + T8t; + T8Q = T8s - T8t; + T8H = KP707106781 * (T7r - T7w); + T8I = T87 - T84; + T8J = T8H + T8I; + T8V = T8I - T8H; + } + { + E T8x, T8A, T8E, T8F; + T8x = FNMS(KP382683432, T8w, KP923879532 * T8v); + T8A = FMA(KP923879532, T8y, KP382683432 * T8z); + T8B = T8x + T8A; + T8U = T8A - T8x; + T8E = FMA(KP382683432, T8v, KP923879532 * T8w); + T8F = FNMS(KP382683432, T8y, KP923879532 * T8z); + T8G = T8E + T8F; + T8R = T8E - T8F; + } + { + E T8C, T8K, T8r, T8D; + T8C = T8u + T8B; + T8K = T8G + T8J; + T8r = W[6]; + T8D = W[7]; + rio[WS(ios, 4)] = FNMS(T8D, T8K, T8r * T8C); + iio[-WS(ios, 59)] = FMA(T8D, T8C, T8r * T8K); + } + { + E T8Y, T90, T8X, T8Z; + T8Y = T8Q - T8R; + T90 = T8V - T8U; + T8X = W[38]; + T8Z = W[39]; + rio[WS(ios, 20)] = FNMS(T8Z, T90, T8X * T8Y); + iio[-WS(ios, 43)] = FMA(T8Z, T8Y, T8X * T90); + } + { + E T8M, T8O, T8L, T8N; + T8M = T8u - T8B; + T8O = T8J - T8G; + T8L = W[70]; + T8N = W[71]; + rio[WS(ios, 36)] = FNMS(T8N, T8O, T8L * T8M); + iio[-WS(ios, 27)] = FMA(T8N, T8M, T8L * T8O); + } + { + E T8S, T8W, T8P, T8T; + T8S = T8Q + T8R; + T8W = T8U + T8V; + T8P = W[102]; + T8T = W[103]; + rio[WS(ios, 52)] = FNMS(T8T, T8W, T8P * T8S); + iio[-WS(ios, 11)] = FMA(T8T, T8S, T8P * T8W); + } + } + { + E T7y, T8g, T89, T8l, T7V, T8k, T80, T8h; + { + E T7m, T7x, T83, T88; + T7m = T7i + T7l; + T7x = KP707106781 * (T7r + T7w); + T7y = T7m + T7x; + T8g = T7m - T7x; + T83 = KP707106781 * (T81 + T82); + T88 = T84 + T87; + T89 = T83 + T88; + T8l = T88 - T83; + } + { + E T7J, T7U, T7Y, T7Z; + T7J = FMA(KP923879532, T7D, KP382683432 * T7I); + T7U = FNMS(KP382683432, T7T, KP923879532 * T7O); + T7V = T7J + T7U; + T8k = T7J - T7U; + T7Y = FNMS(KP382683432, T7D, KP923879532 * T7I); + T7Z = FMA(KP382683432, T7O, KP923879532 * T7T); + T80 = T7Y + T7Z; + T8h = T7Z - T7Y; + } + { + E T7W, T8a, T7h, T7X; + T7W = T7y + T7V; + T8a = T80 + T89; + T7h = W[118]; + T7X = W[119]; + rio[WS(ios, 60)] = FNMS(T7X, T8a, T7h * T7W); + iio[-WS(ios, 3)] = FMA(T7X, T7W, T7h * T8a); + } + { + E T8o, T8q, T8n, T8p; + T8o = T8g - T8h; + T8q = T8l - T8k; + T8n = W[86]; + T8p = W[87]; + rio[WS(ios, 44)] = FNMS(T8p, T8q, T8n * T8o); + iio[-WS(ios, 19)] = FMA(T8p, T8o, T8n * T8q); + } + { + E T8c, T8e, T8b, T8d; + T8c = T7y - T7V; + T8e = T89 - T80; + T8b = W[54]; + T8d = W[55]; + rio[WS(ios, 28)] = FNMS(T8d, T8e, T8b * T8c); + iio[-WS(ios, 35)] = FMA(T8d, T8c, T8b * T8e); + } + { + E T8i, T8m, T8f, T8j; + T8i = T8g + T8h; + T8m = T8k + T8l; + T8f = W[22]; + T8j = W[23]; + rio[WS(ios, 12)] = FNMS(T8j, T8m, T8f * T8i); + iio[-WS(ios, 51)] = FMA(T8j, T8i, T8f * T8m); + } + } + { + E T6K, T76, T6Z, T7b, T6R, T7a, T6W, T77; + { + E T6I, T6J, T6X, T6Y; + T6I = T5O - T5P; + T6J = T6j - T6k; + T6K = T6I + T6J; + T76 = T6I - T6J; + T6X = T5W - T5T; + T6Y = T6n - T6m; + T6Z = T6X + T6Y; + T7b = T6Y - T6X; + { + E T6N, T6U, T6Q, T6V; + { + E T6L, T6M, T6O, T6P; + T6L = T5Z - T60; + T6M = T63 - T62; + T6N = FMA(KP831469612, T6L, KP555570233 * T6M); + T6U = FNMS(KP555570233, T6L, KP831469612 * T6M); + T6O = T66 - T67; + T6P = T6a - T69; + T6Q = FNMS(KP555570233, T6P, KP831469612 * T6O); + T6V = FMA(KP555570233, T6O, KP831469612 * T6P); + } + T6R = T6N + T6Q; + T7a = T6N - T6Q; + T6W = T6U + T6V; + T77 = T6V - T6U; + } + } + { + E T6S, T70, T6H, T6T; + T6S = T6K + T6R; + T70 = T6W + T6Z; + T6H = W[114]; + T6T = W[115]; + rio[WS(ios, 58)] = FNMS(T6T, T70, T6H * T6S); + iio[-WS(ios, 5)] = FMA(T6T, T6S, T6H * T70); + } + { + E T7e, T7g, T7d, T7f; + T7e = T76 - T77; + T7g = T7b - T7a; + T7d = W[82]; + T7f = W[83]; + rio[WS(ios, 42)] = FNMS(T7f, T7g, T7d * T7e); + iio[-WS(ios, 21)] = FMA(T7f, T7e, T7d * T7g); + } + { + E T72, T74, T71, T73; + T72 = T6K - T6R; + T74 = T6Z - T6W; + T71 = W[50]; + T73 = W[51]; + rio[WS(ios, 26)] = FNMS(T73, T74, T71 * T72); + iio[-WS(ios, 37)] = FMA(T73, T72, T71 * T74); + } + { + E T78, T7c, T75, T79; + T78 = T76 + T77; + T7c = T7a + T7b; + T75 = W[18]; + T79 = W[19]; + rio[WS(ios, 10)] = FNMS(T79, T7c, T75 * T78); + iio[-WS(ios, 53)] = FMA(T79, T78, T75 * T7c); + } + } + { + E T3a, T52, T4V, T57, T4z, T56, T4E, T53; + { + E T2w, T39, T4H, T4U; + T2w = T2c + T2v; + T39 = T2P + T38; + T3a = T2w + T39; + T52 = T2w - T39; + T4H = T4F + T4G; + T4U = T4K + T4T; + T4V = T4H + T4U; + T57 = T4U - T4H; + { + E T3R, T4C, T4y, T4D; + { + E T3D, T3Q, T4k, T4x; + T3D = T3j + T3C; + T3Q = T3G + T3P; + T3R = FMA(KP980785280, T3D, KP195090322 * T3Q); + T4C = FNMS(KP195090322, T3D, KP980785280 * T3Q); + T4k = T40 + T4j; + T4x = T4n + T4w; + T4y = FNMS(KP195090322, T4x, KP980785280 * T4k); + T4D = FMA(KP195090322, T4k, KP980785280 * T4x); + } + T4z = T3R + T4y; + T56 = T3R - T4y; + T4E = T4C + T4D; + T53 = T4D - T4C; + } + } + { + E T4A, T4W, T23, T4B; + T4A = T3a + T4z; + T4W = T4E + T4V; + T23 = W[122]; + T4B = W[123]; + rio[WS(ios, 62)] = FNMS(T4B, T4W, T23 * T4A); + iio[-WS(ios, 1)] = FMA(T4B, T4A, T23 * T4W); + } + { + E T5a, T5c, T59, T5b; + T5a = T52 - T53; + T5c = T57 - T56; + T59 = W[90]; + T5b = W[91]; + rio[WS(ios, 46)] = FNMS(T5b, T5c, T59 * T5a); + iio[-WS(ios, 17)] = FMA(T5b, T5a, T59 * T5c); + } + { + E T4Y, T50, T4X, T4Z; + T4Y = T3a - T4z; + T50 = T4V - T4E; + T4X = W[58]; + T4Z = W[59]; + rio[WS(ios, 30)] = FNMS(T4Z, T50, T4X * T4Y); + iio[-WS(ios, 33)] = FMA(T4Z, T4Y, T4X * T50); + } + { + E T54, T58, T51, T55; + T54 = T52 + T53; + T58 = T56 + T57; + T51 = W[26]; + T55 = W[27]; + rio[WS(ios, 14)] = FNMS(T55, T58, T51 * T54); + iio[-WS(ios, 49)] = FMA(T55, T54, T51 * T58); + } + } + { + E T5g, T5C, T5v, T5H, T5n, T5G, T5s, T5D; + { + E T5e, T5f, T5t, T5u; + T5e = T2c - T2v; + T5f = T4G - T4F; + T5g = T5e + T5f; + T5C = T5e - T5f; + T5t = T2P - T38; + T5u = T4T - T4K; + T5v = T5t + T5u; + T5H = T5u - T5t; + { + E T5j, T5q, T5m, T5r; + { + E T5h, T5i, T5k, T5l; + T5h = T3j - T3C; + T5i = T3P - T3G; + T5j = FNMS(KP555570233, T5i, KP831469612 * T5h); + T5q = FMA(KP555570233, T5h, KP831469612 * T5i); + T5k = T40 - T4j; + T5l = T4w - T4n; + T5m = FMA(KP831469612, T5k, KP555570233 * T5l); + T5r = FNMS(KP555570233, T5k, KP831469612 * T5l); + } + T5n = T5j + T5m; + T5G = T5m - T5j; + T5s = T5q + T5r; + T5D = T5q - T5r; + } + } + { + E T5o, T5w, T5d, T5p; + T5o = T5g + T5n; + T5w = T5s + T5v; + T5d = W[10]; + T5p = W[11]; + rio[WS(ios, 6)] = FNMS(T5p, T5w, T5d * T5o); + iio[-WS(ios, 57)] = FMA(T5p, T5o, T5d * T5w); + } + { + E T5K, T5M, T5J, T5L; + T5K = T5C - T5D; + T5M = T5H - T5G; + T5J = W[42]; + T5L = W[43]; + rio[WS(ios, 22)] = FNMS(T5L, T5M, T5J * T5K); + iio[-WS(ios, 41)] = FMA(T5L, T5K, T5J * T5M); + } + { + E T5y, T5A, T5x, T5z; + T5y = T5g - T5n; + T5A = T5v - T5s; + T5x = W[74]; + T5z = W[75]; + rio[WS(ios, 38)] = FNMS(T5z, T5A, T5x * T5y); + iio[-WS(ios, 25)] = FMA(T5z, T5y, T5x * T5A); + } + { + E T5E, T5I, T5B, T5F; + T5E = T5C + T5D; + T5I = T5G + T5H; + T5B = W[106]; + T5F = W[107]; + rio[WS(ios, 54)] = FNMS(T5F, T5I, T5B * T5E); + iio[-WS(ios, 9)] = FMA(T5F, T5E, T5B * T5I); + } + } + { + E T5Y, T6w, T6p, T6B, T6d, T6A, T6i, T6x; + { + E T5Q, T5X, T6l, T6o; + T5Q = T5O + T5P; + T5X = T5T + T5W; + T5Y = T5Q + T5X; + T6w = T5Q - T5X; + T6l = T6j + T6k; + T6o = T6m + T6n; + T6p = T6l + T6o; + T6B = T6o - T6l; + { + E T65, T6g, T6c, T6h; + { + E T61, T64, T68, T6b; + T61 = T5Z + T60; + T64 = T62 + T63; + T65 = FNMS(KP195090322, T64, KP980785280 * T61); + T6g = FMA(KP195090322, T61, KP980785280 * T64); + T68 = T66 + T67; + T6b = T69 + T6a; + T6c = FMA(KP980785280, T68, KP195090322 * T6b); + T6h = FNMS(KP195090322, T68, KP980785280 * T6b); + } + T6d = T65 + T6c; + T6A = T6c - T65; + T6i = T6g + T6h; + T6x = T6g - T6h; + } + } + { + E T6e, T6q, T5N, T6f; + T6e = T5Y + T6d; + T6q = T6i + T6p; + T5N = W[2]; + T6f = W[3]; + rio[WS(ios, 2)] = FNMS(T6f, T6q, T5N * T6e); + iio[-WS(ios, 61)] = FMA(T6f, T6e, T5N * T6q); + } + { + E T6E, T6G, T6D, T6F; + T6E = T6w - T6x; + T6G = T6B - T6A; + T6D = W[34]; + T6F = W[35]; + rio[WS(ios, 18)] = FNMS(T6F, T6G, T6D * T6E); + iio[-WS(ios, 45)] = FMA(T6F, T6E, T6D * T6G); + } + { + E T6s, T6u, T6r, T6t; + T6s = T5Y - T6d; + T6u = T6p - T6i; + T6r = W[66]; + T6t = W[67]; + rio[WS(ios, 34)] = FNMS(T6t, T6u, T6r * T6s); + iio[-WS(ios, 29)] = FMA(T6t, T6s, T6r * T6u); + } + { + E T6y, T6C, T6v, T6z; + T6y = T6w + T6x; + T6C = T6A + T6B; + T6v = W[98]; + T6z = W[99]; + rio[WS(ios, 50)] = FNMS(T6z, T6C, T6v * T6y); + iio[-WS(ios, 13)] = FMA(T6z, T6y, T6v * T6C); + } + } + { + E TdO, Tf1, Teq, TeH, Tef, TeW, Ten, TeM, Te3, Ter, Te8, Tem, TeE, Tf0, TeP; + E TeX; + { + E TdG, TeG, TdN, TeF, TdJ, TdM; + TdG = TdE + TdF; + TeG = Ted - Tec; + TdJ = FNMS(KP555570233, TdI, KP831469612 * TdH); + TdM = FMA(KP831469612, TdK, KP555570233 * TdL); + TdN = TdJ + TdM; + TeF = TdM - TdJ; + TdO = TdG + TdN; + Tf1 = TeG - TeF; + Teq = TdG - TdN; + TeH = TeF + TeG; + } + { + E Tee, TeK, Teb, TeL, Te9, Tea; + Tee = Tec + Ted; + TeK = TdE - TdF; + Te9 = FMA(KP555570233, TdH, KP831469612 * TdI); + Tea = FNMS(KP555570233, TdK, KP831469612 * TdL); + Teb = Te9 + Tea; + TeL = Te9 - Tea; + Tef = Teb + Tee; + TeW = TeK - TeL; + Ten = Tee - Teb; + TeM = TeK + TeL; + } + { + E TdV, Te6, Te2, Te7; + { + E TdR, TdU, TdY, Te1; + TdR = TdP + TdQ; + TdU = TdS + TdT; + TdV = FNMS(KP290284677, TdU, KP956940335 * TdR); + Te6 = FMA(KP290284677, TdR, KP956940335 * TdU); + TdY = TdW + TdX; + Te1 = TdZ + Te0; + Te2 = FMA(KP956940335, TdY, KP290284677 * Te1); + Te7 = FNMS(KP290284677, TdY, KP956940335 * Te1); + } + Te3 = TdV + Te2; + Ter = Te6 - Te7; + Te8 = Te6 + Te7; + Tem = Te2 - TdV; + } + { + E TeA, TeN, TeD, TeO; + { + E Tey, Tez, TeB, TeC; + Tey = TdT - TdS; + Tez = TdP - TdQ; + TeA = FNMS(KP471396736, Tez, KP881921264 * Tey); + TeN = FMA(KP881921264, Tez, KP471396736 * Tey); + TeB = TdW - TdX; + TeC = Te0 - TdZ; + TeD = FMA(KP471396736, TeB, KP881921264 * TeC); + TeO = FNMS(KP471396736, TeC, KP881921264 * TeB); + } + TeE = TeA + TeD; + Tf0 = TeN - TeO; + TeP = TeN + TeO; + TeX = TeD - TeA; + } + { + E Te4, Teg, TdD, Te5; + Te4 = TdO + Te3; + Teg = Te8 + Tef; + TdD = W[120]; + Te5 = W[121]; + iio[-WS(ios, 2)] = FMA(TdD, Te4, Te5 * Teg); + rio[WS(ios, 61)] = FNMS(Te5, Te4, TdD * Teg); + } + { + E TeY, Tf2, TeV, TeZ; + TeY = TeW + TeX; + Tf2 = Tf0 + Tf1; + TeV = W[104]; + TeZ = W[105]; + iio[-WS(ios, 10)] = FMA(TeV, TeY, TeZ * Tf2); + rio[WS(ios, 53)] = FNMS(TeZ, TeY, TeV * Tf2); + } + { + E Tf4, Tf6, Tf3, Tf5; + Tf4 = Tf1 - Tf0; + Tf6 = TeW - TeX; + Tf3 = W[40]; + Tf5 = W[41]; + rio[WS(ios, 21)] = FNMS(Tf5, Tf6, Tf3 * Tf4); + iio[-WS(ios, 42)] = FMA(Tf3, Tf6, Tf5 * Tf4); + } + { + E Tei, Tek, Teh, Tej; + Tei = Tef - Te8; + Tek = TdO - Te3; + Teh = W[56]; + Tej = W[57]; + rio[WS(ios, 29)] = FNMS(Tej, Tek, Teh * Tei); + iio[-WS(ios, 34)] = FMA(Teh, Tek, Tej * Tei); + } + { + E Teo, Tes, Tel, Tep; + Teo = Tem + Ten; + Tes = Teq + Ter; + Tel = W[24]; + Tep = W[25]; + rio[WS(ios, 13)] = FNMS(Tep, Tes, Tel * Teo); + iio[-WS(ios, 50)] = FMA(Tel, Tes, Tep * Teo); + } + { + E TeI, TeQ, Tex, TeJ; + TeI = TeE + TeH; + TeQ = TeM + TeP; + Tex = W[8]; + TeJ = W[9]; + rio[WS(ios, 5)] = FNMS(TeJ, TeQ, Tex * TeI); + iio[-WS(ios, 58)] = FMA(Tex, TeQ, TeJ * TeI); + } + { + E TeS, TeU, TeR, TeT; + TeS = TeM - TeP; + TeU = TeH - TeE; + TeR = W[72]; + TeT = W[73]; + iio[-WS(ios, 26)] = FMA(TeR, TeS, TeT * TeU); + rio[WS(ios, 37)] = FNMS(TeT, TeS, TeR * TeU); + } + { + E Teu, Tew, Tet, Tev; + Teu = Teq - Ter; + Tew = Ten - Tem; + Tet = W[88]; + Tev = W[89]; + iio[-WS(ios, 18)] = FMA(Tet, Teu, Tev * Tew); + rio[WS(ios, 45)] = FNMS(Tev, Teu, Tet * Tew); + } + } + { + E Tcr, Tdw, TcX, Td6, TcI, Tdt, TcS, Tdl, Tbm, TcW, TcL, TcT, Tdd, Tdx, Tdi; + E Tds; + { + E Tcq, Td4, TbZ, Td5, TbF, TbY; + Tcq = Tce + Tcp; + Td4 = TcA - TcD; + TbF = FNMS(KP195090322, TbE, KP980785280 * Tbx); + TbY = FMA(KP195090322, TbQ, KP980785280 * TbX); + TbZ = TbF + TbY; + Td5 = TbY - TbF; + Tcr = TbZ + Tcq; + Tdw = Td4 - Td5; + TcX = Tcq - TbZ; + Td6 = Td4 + Td5; + } + { + E TcE, Tdk, TcH, Tdj, TcF, TcG; + TcE = TcA + TcD; + Tdk = Tcp - Tce; + TcF = FMA(KP980785280, TbE, KP195090322 * Tbx); + TcG = FNMS(KP195090322, TbX, KP980785280 * TbQ); + TcH = TcF + TcG; + Tdj = TcF - TcG; + TcI = TcE + TcH; + Tdt = Tdk - Tdj; + TcS = TcE - TcH; + Tdl = Tdj + Tdk; + } + { + E TaI, TcJ, Tbl, TcK; + { + E Taw, TaH, Tb9, Tbk; + Taw = Tak + Tav; + TaH = TaD + TaG; + TaI = FNMS(KP098017140, TaH, KP995184726 * Taw); + TcJ = FMA(KP995184726, TaH, KP098017140 * Taw); + Tb9 = TaT + Tb8; + Tbk = Tbc + Tbj; + Tbl = FMA(KP098017140, Tb9, KP995184726 * Tbk); + TcK = FNMS(KP098017140, Tbk, KP995184726 * Tb9); + } + Tbm = TaI + Tbl; + TcW = TcJ - TcK; + TcL = TcJ + TcK; + TcT = Tbl - TaI; + } + { + E Td9, Tdg, Tdc, Tdh; + { + E Td7, Td8, Tda, Tdb; + Td7 = TaD - TaG; + Td8 = Tav - Tak; + Td9 = FNMS(KP634393284, Td8, KP773010453 * Td7); + Tdg = FMA(KP634393284, Td7, KP773010453 * Td8); + Tda = TaT - Tb8; + Tdb = Tbj - Tbc; + Tdc = FMA(KP773010453, Tda, KP634393284 * Tdb); + Tdh = FNMS(KP634393284, Tda, KP773010453 * Tdb); + } + Tdd = Td9 + Tdc; + Tdx = Tdg - Tdh; + Tdi = Tdg + Tdh; + Tds = Tdc - Td9; + } + { + E Tcs, TcM, Ta5, Tct; + Tcs = Tbm + Tcr; + TcM = TcI + TcL; + Ta5 = W[0]; + Tct = W[1]; + rio[WS(ios, 1)] = FNMS(Tct, TcM, Ta5 * Tcs); + iio[-WS(ios, 62)] = FMA(Ta5, TcM, Tct * Tcs); + } + { + E Tdu, Tdy, Tdr, Tdv; + Tdu = Tds + Tdt; + Tdy = Tdw + Tdx; + Tdr = W[16]; + Tdv = W[17]; + rio[WS(ios, 9)] = FNMS(Tdv, Tdy, Tdr * Tdu); + iio[-WS(ios, 54)] = FMA(Tdr, Tdy, Tdv * Tdu); + } + { + E TdA, TdC, Tdz, TdB; + TdA = Tdw - Tdx; + TdC = Tdt - Tds; + Tdz = W[80]; + TdB = W[81]; + iio[-WS(ios, 22)] = FMA(Tdz, TdA, TdB * TdC); + rio[WS(ios, 41)] = FNMS(TdB, TdA, Tdz * TdC); + } + { + E TcO, TcQ, TcN, TcP; + TcO = TcI - TcL; + TcQ = Tcr - Tbm; + TcN = W[64]; + TcP = W[65]; + iio[-WS(ios, 30)] = FMA(TcN, TcO, TcP * TcQ); + rio[WS(ios, 33)] = FNMS(TcP, TcO, TcN * TcQ); + } + { + E TcU, TcY, TcR, TcV; + TcU = TcS + TcT; + TcY = TcW + TcX; + TcR = W[96]; + TcV = W[97]; + iio[-WS(ios, 14)] = FMA(TcR, TcU, TcV * TcY); + rio[WS(ios, 49)] = FNMS(TcV, TcU, TcR * TcY); + } + { + E Tde, Tdm, Td3, Tdf; + Tde = Td6 + Tdd; + Tdm = Tdi + Tdl; + Td3 = W[112]; + Tdf = W[113]; + iio[-WS(ios, 6)] = FMA(Td3, Tde, Tdf * Tdm); + rio[WS(ios, 57)] = FNMS(Tdf, Tde, Td3 * Tdm); + } + { + E Tdo, Tdq, Tdn, Tdp; + Tdo = Tdl - Tdi; + Tdq = Td6 - Tdd; + Tdn = W[48]; + Tdp = W[49]; + rio[WS(ios, 25)] = FNMS(Tdp, Tdq, Tdn * Tdo); + iio[-WS(ios, 38)] = FMA(Tdn, Tdq, Tdp * Tdo); + } + { + E Td0, Td2, TcZ, Td1; + Td0 = TcX - TcW; + Td2 = TcS - TcT; + TcZ = W[32]; + Td1 = W[33]; + rio[WS(ios, 17)] = FNMS(Td1, Td2, TcZ * Td0); + iio[-WS(ios, 46)] = FMA(TcZ, Td2, Td1 * Td0); + } + } + { + E Tfy, Thd, TgC, TgT, Tgr, Th8, Tgz, TgY, Tgb, TgD, Tgg, Tgy, TgQ, Thc, Th1; + E Th9; + { + E Tfi, TgS, Tfx, TgR, Tfp, Tfw; + Tfi = Tfa + Tfh; + TgS = Tgp - Tgm; + Tfp = FNMS(KP195090322, Tfo, KP980785280 * Tfl); + Tfw = FMA(KP980785280, Tfs, KP195090322 * Tfv); + Tfx = Tfp + Tfw; + TgR = Tfw - Tfp; + Tfy = Tfi + Tfx; + Thd = TgS - TgR; + TgC = Tfi - Tfx; + TgT = TgR + TgS; + } + { + E Tgq, TgW, Tgj, TgX, Tgh, Tgi; + Tgq = Tgm + Tgp; + TgW = Tfa - Tfh; + Tgh = FMA(KP195090322, Tfl, KP980785280 * Tfo); + Tgi = FNMS(KP195090322, Tfs, KP980785280 * Tfv); + Tgj = Tgh + Tgi; + TgX = Tgh - Tgi; + Tgr = Tgj + Tgq; + Th8 = TgW - TgX; + Tgz = Tgq - Tgj; + TgY = TgW + TgX; + } + { + E TfR, Tge, Tga, Tgf; + { + E TfJ, TfQ, Tg2, Tg9; + TfJ = TfB + TfI; + TfQ = TfM + TfP; + TfR = FNMS(KP098017140, TfQ, KP995184726 * TfJ); + Tge = FMA(KP098017140, TfJ, KP995184726 * TfQ); + Tg2 = TfU + Tg1; + Tg9 = Tg5 + Tg8; + Tga = FMA(KP995184726, Tg2, KP098017140 * Tg9); + Tgf = FNMS(KP098017140, Tg2, KP995184726 * Tg9); + } + Tgb = TfR + Tga; + TgD = Tge - Tgf; + Tgg = Tge + Tgf; + Tgy = Tga - TfR; + } + { + E TgM, TgZ, TgP, Th0; + { + E TgK, TgL, TgN, TgO; + TgK = TfP - TfM; + TgL = TfB - TfI; + TgM = FNMS(KP634393284, TgL, KP773010453 * TgK); + TgZ = FMA(KP773010453, TgL, KP634393284 * TgK); + TgN = TfU - Tg1; + TgO = Tg8 - Tg5; + TgP = FMA(KP634393284, TgN, KP773010453 * TgO); + Th0 = FNMS(KP634393284, TgO, KP773010453 * TgN); + } + TgQ = TgM + TgP; + Thc = TgZ - Th0; + Th1 = TgZ + Th0; + Th9 = TgP - TgM; + } + { + E Tgc, Tgs, Tf7, Tgd; + Tgc = Tfy + Tgb; + Tgs = Tgg + Tgr; + Tf7 = W[124]; + Tgd = W[125]; + iio[0] = FMA(Tf7, Tgc, Tgd * Tgs); + rio[WS(ios, 63)] = FNMS(Tgd, Tgc, Tf7 * Tgs); + } + { + E Tha, The, Th7, Thb; + Tha = Th8 + Th9; + The = Thc + Thd; + Th7 = W[108]; + Thb = W[109]; + iio[-WS(ios, 8)] = FMA(Th7, Tha, Thb * The); + rio[WS(ios, 55)] = FNMS(Thb, Tha, Th7 * The); + } + { + E Thg, Thi, Thf, Thh; + Thg = Thd - Thc; + Thi = Th8 - Th9; + Thf = W[44]; + Thh = W[45]; + rio[WS(ios, 23)] = FNMS(Thh, Thi, Thf * Thg); + iio[-WS(ios, 40)] = FMA(Thf, Thi, Thh * Thg); + } + { + E Tgu, Tgw, Tgt, Tgv; + Tgu = Tgr - Tgg; + Tgw = Tfy - Tgb; + Tgt = W[60]; + Tgv = W[61]; + rio[WS(ios, 31)] = FNMS(Tgv, Tgw, Tgt * Tgu); + iio[-WS(ios, 32)] = FMA(Tgt, Tgw, Tgv * Tgu); + } + { + E TgA, TgE, Tgx, TgB; + TgA = Tgy + Tgz; + TgE = TgC + TgD; + Tgx = W[28]; + TgB = W[29]; + rio[WS(ios, 15)] = FNMS(TgB, TgE, Tgx * TgA); + iio[-WS(ios, 48)] = FMA(Tgx, TgE, TgB * TgA); + } + { + E TgU, Th2, TgJ, TgV; + TgU = TgQ + TgT; + Th2 = TgY + Th1; + TgJ = W[12]; + TgV = W[13]; + rio[WS(ios, 7)] = FNMS(TgV, Th2, TgJ * TgU); + iio[-WS(ios, 56)] = FMA(TgJ, Th2, TgV * TgU); + } + { + E Th4, Th6, Th3, Th5; + Th4 = TgY - Th1; + Th6 = TgT - TgQ; + Th3 = W[76]; + Th5 = W[77]; + iio[-WS(ios, 24)] = FMA(Th3, Th4, Th5 * Th6); + rio[WS(ios, 39)] = FNMS(Th5, Th4, Th3 * Th6); + } + { + E TgG, TgI, TgF, TgH; + TgG = TgC - TgD; + TgI = Tgz - Tgy; + TgF = W[92]; + TgH = W[93]; + iio[-WS(ios, 16)] = FMA(TgF, TgG, TgH * TgI); + rio[WS(ios, 47)] = FNMS(TgH, TgG, TgF * TgI); + } + } + { + E ThJ, TiG, Ti7, Tig, ThS, TiD, Ti2, Tiv, Thy, Ti6, ThV, Ti3, Tin, TiH, Tis; + E TiC; + { + E ThI, Tie, ThF, Tif, ThB, ThE; + ThI = ThG + ThH; + Tie = ThM - ThN; + ThB = FNMS(KP555570233, ThA, KP831469612 * Thz); + ThE = FNMS(KP555570233, ThD, KP831469612 * ThC); + ThF = ThB + ThE; + Tif = ThE - ThB; + ThJ = ThF + ThI; + TiG = Tie - Tif; + Ti7 = ThI - ThF; + Tig = Tie + Tif; + } + { + E ThO, Tiu, ThR, Tit, ThP, ThQ; + ThO = ThM + ThN; + Tiu = ThH - ThG; + ThP = FMA(KP831469612, ThA, KP555570233 * Thz); + ThQ = FMA(KP831469612, ThD, KP555570233 * ThC); + ThR = ThP - ThQ; + Tit = ThP + ThQ; + ThS = ThO + ThR; + TiD = Tiu - Tit; + Ti2 = ThO - ThR; + Tiv = Tit + Tiu; + } + { + E Thq, ThT, Thx, ThU; + { + E Thm, Thp, Tht, Thw; + Thm = Thk + Thl; + Thp = Thn + Tho; + Thq = FNMS(KP290284677, Thp, KP956940335 * Thm); + ThT = FMA(KP956940335, Thp, KP290284677 * Thm); + Tht = Thr - Ths; + Thw = Thu + Thv; + Thx = FMA(KP290284677, Tht, KP956940335 * Thw); + ThU = FNMS(KP290284677, Thw, KP956940335 * Tht); + } + Thy = Thq + Thx; + Ti6 = ThT - ThU; + ThV = ThT + ThU; + Ti3 = Thx - Thq; + } + { + E Tij, Tiq, Tim, Tir; + { + E Tih, Tii, Tik, Til; + Tih = Thn - Tho; + Tii = Thl - Thk; + Tij = FNMS(KP471396736, Tii, KP881921264 * Tih); + Tiq = FMA(KP471396736, Tih, KP881921264 * Tii); + Tik = Thv - Thu; + Til = Ths + Thr; + Tim = FNMS(KP881921264, Til, KP471396736 * Tik); + Tir = FMA(KP471396736, Til, KP881921264 * Tik); + } + Tin = Tij + Tim; + TiH = Tiq - Tir; + Tis = Tiq + Tir; + TiC = Tim - Tij; + } + { + E ThK, ThW, Thj, ThL; + ThK = Thy + ThJ; + ThW = ThS + ThV; + Thj = W[4]; + ThL = W[5]; + rio[WS(ios, 3)] = FNMS(ThL, ThW, Thj * ThK); + iio[-WS(ios, 60)] = FMA(Thj, ThW, ThL * ThK); + } + { + E TiE, TiI, TiB, TiF; + TiE = TiC + TiD; + TiI = TiG + TiH; + TiB = W[20]; + TiF = W[21]; + rio[WS(ios, 11)] = FNMS(TiF, TiI, TiB * TiE); + iio[-WS(ios, 52)] = FMA(TiB, TiI, TiF * TiE); + } + { + E TiK, TiM, TiJ, TiL; + TiK = TiG - TiH; + TiM = TiD - TiC; + TiJ = W[84]; + TiL = W[85]; + iio[-WS(ios, 20)] = FMA(TiJ, TiK, TiL * TiM); + rio[WS(ios, 43)] = FNMS(TiL, TiK, TiJ * TiM); + } + { + E ThY, Ti0, ThX, ThZ; + ThY = ThS - ThV; + Ti0 = ThJ - Thy; + ThX = W[68]; + ThZ = W[69]; + iio[-WS(ios, 28)] = FMA(ThX, ThY, ThZ * Ti0); + rio[WS(ios, 35)] = FNMS(ThZ, ThY, ThX * Ti0); + } + { + E Ti4, Ti8, Ti1, Ti5; + Ti4 = Ti2 + Ti3; + Ti8 = Ti6 + Ti7; + Ti1 = W[100]; + Ti5 = W[101]; + iio[-WS(ios, 12)] = FMA(Ti1, Ti4, Ti5 * Ti8); + rio[WS(ios, 51)] = FNMS(Ti5, Ti4, Ti1 * Ti8); + } + { + E Tio, Tiw, Tid, Tip; + Tio = Tig + Tin; + Tiw = Tis + Tiv; + Tid = W[116]; + Tip = W[117]; + iio[-WS(ios, 4)] = FMA(Tid, Tio, Tip * Tiw); + rio[WS(ios, 59)] = FNMS(Tip, Tio, Tid * Tiw); + } + { + E Tiy, TiA, Tix, Tiz; + Tiy = Tiv - Tis; + TiA = Tig - Tin; + Tix = W[52]; + Tiz = W[53]; + rio[WS(ios, 27)] = FNMS(Tiz, TiA, Tix * Tiy); + iio[-WS(ios, 36)] = FMA(Tix, TiA, Tiz * Tiy); + } + { + E Tia, Tic, Ti9, Tib; + Tia = Ti7 - Ti6; + Tic = Ti2 - Ti3; + Ti9 = W[36]; + Tib = W[37]; + rio[WS(ios, 19)] = FNMS(Tib, Tic, Ti9 * Tia); + iio[-WS(ios, 44)] = FMA(Ti9, Tic, Tib * Tia); + } + } + } + return W; +} + +static const tw_instr twinstr[] = { + {TW_FULL, 0, 64}, + {TW_NEXT, 1, 0} +}; + +static const hc2hc_desc desc = { 64, "hb_64", twinstr, {808, 270, 230, 0}, &GENUS, 0, 0, 0 }; + +void X(codelet_hb_64) (planner *p) { + X(khc2hc_dif_register) (p, hb_64, &desc); +} diff --git a/src/fftw3/rdft/codelets/hc2r/hb_7.c b/src/fftw3/rdft/codelets/hc2r/hb_7.c new file mode 100644 index 0000000..4993e5e --- /dev/null +++ b/src/fftw3/rdft/codelets/hc2r/hb_7.c @@ -0,0 +1,173 @@ +/* + * Copyright (c) 2003 Matteo Frigo + * Copyright (c) 2003 Massachusetts Institute of Technology + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +/* This file was automatically generated --- DO NOT EDIT */ +/* Generated on Sat Jul 5 22:11:26 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_hc2hc -compact -variables 4 -sign 1 -n 7 -dif -name hb_7 -include hb.h */ + +/* + * This function contains 72 FP additions, 60 FP multiplications, + * (or, 36 additions, 24 multiplications, 36 fused multiply/add), + * 36 stack variables, and 28 memory accesses + */ +/* + * Generator Id's : + * $Id: hb_7.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: hb_7.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: hb_7.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + */ + +#include "hb.h" + +static const R *hb_7(R *rio, R *iio, const R *W, stride ios, int m, int dist) +{ + DK(KP222520933, +0.222520933956314404288902564496794759466355569); + DK(KP900968867, +0.900968867902419126236102319507445051165919162); + DK(KP623489801, +0.623489801858733530525004884004239810632274731); + DK(KP781831482, +0.781831482468029808708444526674057750232334519); + DK(KP974927912, +0.974927912181823607018131682993931217232785801); + DK(KP433883739, +0.433883739117558120475768332848358754609990728); + int i; + for (i = m - 2; i > 0; i = i - 2, rio = rio + dist, iio = iio - dist, W = W + 12) { + E T1, Ta, T4, T7, Tq, TI, TR, TU, TE, Tt, Tb, Tk, Te, Th, Tx; + E TF, TV, TQ, TJ, Tm; + { + E To, Tn, Tp, T8, T9; + T1 = rio[0]; + T8 = rio[WS(ios, 3)]; + T9 = iio[-WS(ios, 4)]; + Ta = T8 + T9; + To = T8 - T9; + { + E T2, T3, T5, T6; + T2 = rio[WS(ios, 1)]; + T3 = iio[-WS(ios, 6)]; + T4 = T2 + T3; + Tn = T2 - T3; + T5 = rio[WS(ios, 2)]; + T6 = iio[-WS(ios, 5)]; + T7 = T5 + T6; + Tp = T5 - T6; + } + Tq = FMA(KP433883739, Tn, KP974927912 * To) - (KP781831482 * Tp); + TI = FMA(KP781831482, Tn, KP974927912 * Tp) + (KP433883739 * To); + TR = FNMS(KP781831482, To, KP974927912 * Tn) - (KP433883739 * Tp); + TU = FMA(KP623489801, Ta, T1) + FNMA(KP900968867, T7, KP222520933 * T4); + TE = FMA(KP623489801, T4, T1) + FNMA(KP900968867, Ta, KP222520933 * T7); + Tt = FMA(KP623489801, T7, T1) + FNMA(KP222520933, Ta, KP900968867 * T4); + } + { + E Tv, Tw, Tu, Ti, Tj; + Tb = iio[0]; + Ti = rio[WS(ios, 4)]; + Tj = iio[-WS(ios, 3)]; + Tk = Ti - Tj; + Tv = Ti + Tj; + { + E Tc, Td, Tf, Tg; + Tc = iio[-WS(ios, 1)]; + Td = rio[WS(ios, 6)]; + Te = Tc - Td; + Tw = Tc + Td; + Tf = rio[WS(ios, 5)]; + Tg = iio[-WS(ios, 2)]; + Th = Tf - Tg; + Tu = Tf + Tg; + } + Tx = FNMS(KP974927912, Tv, KP781831482 * Tu) - (KP433883739 * Tw); + TF = FMA(KP781831482, Tw, KP974927912 * Tu) + (KP433883739 * Tv); + TV = FMA(KP433883739, Tu, KP781831482 * Tv) - (KP974927912 * Tw); + TQ = FMA(KP900968867, Th, Tb) + FNMA(KP623489801, Tk, KP222520933 * Te); + TJ = FMA(KP623489801, Te, Tb) + FMA(KP222520933, Th, KP900968867 * Tk); + Tm = FMA(KP222520933, Tk, Tb) + FNMA(KP623489801, Th, KP900968867 * Te); + } + rio[0] = T1 + T4 + T7 + Ta; + iio[-WS(ios, 6)] = Tb + Te - (Th + Tk); + { + E TM, TO, TL, TN; + TM = TJ - TI; + TO = TE + TF; + TL = W[10]; + TN = W[11]; + iio[0] = FMA(TL, TM, TN * TO); + rio[WS(ios, 6)] = FNMS(TN, TM, TL * TO); + } + { + E TY, T10, TX, TZ; + TY = TU + TV; + T10 = TR + TQ; + TX = W[2]; + TZ = W[3]; + rio[WS(ios, 2)] = FNMS(TZ, T10, TX * TY); + iio[-WS(ios, 4)] = FMA(TX, T10, TZ * TY); + } + { + E Tr, Ty, Tl, Ts; + Tr = Tm - Tq; + Ty = Tt - Tx; + Tl = W[6]; + Ts = W[7]; + iio[-WS(ios, 2)] = FMA(Tl, Tr, Ts * Ty); + rio[WS(ios, 4)] = FNMS(Ts, Tr, Tl * Ty); + } + { + E TA, TC, Tz, TB; + TA = Tt + Tx; + TC = Tq + Tm; + Tz = W[4]; + TB = W[5]; + rio[WS(ios, 3)] = FNMS(TB, TC, Tz * TA); + iio[-WS(ios, 3)] = FMA(Tz, TC, TB * TA); + } + { + E TS, TW, TP, TT; + TS = TQ - TR; + TW = TU - TV; + TP = W[8]; + TT = W[9]; + iio[-WS(ios, 1)] = FMA(TP, TS, TT * TW); + rio[WS(ios, 5)] = FNMS(TT, TS, TP * TW); + } + { + E TG, TK, TD, TH; + TG = TE - TF; + TK = TI + TJ; + TD = W[0]; + TH = W[1]; + rio[WS(ios, 1)] = FNMS(TH, TK, TD * TG); + iio[-WS(ios, 5)] = FMA(TD, TK, TH * TG); + } + } + return W; +} + +static const tw_instr twinstr[] = { + {TW_FULL, 0, 7}, + {TW_NEXT, 1, 0} +}; + +static const hc2hc_desc desc = { 7, "hb_7", twinstr, {36, 24, 36, 0}, &GENUS, 0, 0, 0 }; + +void X(codelet_hb_7) (planner *p) { + X(khc2hc_dif_register) (p, hb_7, &desc); +} diff --git a/src/fftw3/rdft/codelets/hc2r/hb_8.c b/src/fftw3/rdft/codelets/hc2r/hb_8.c new file mode 100644 index 0000000..58cc25e --- /dev/null +++ b/src/fftw3/rdft/codelets/hc2r/hb_8.c @@ -0,0 +1,197 @@ +/* + * Copyright (c) 2003 Matteo Frigo + * Copyright (c) 2003 Massachusetts Institute of Technology + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +/* This file was automatically generated --- DO NOT EDIT */ +/* Generated on Sat Jul 5 22:11:28 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_hc2hc -compact -variables 4 -sign 1 -n 8 -dif -name hb_8 -include hb.h */ + +/* + * This function contains 66 FP additions, 32 FP multiplications, + * (or, 52 additions, 18 multiplications, 14 fused multiply/add), + * 30 stack variables, and 32 memory accesses + */ +/* + * Generator Id's : + * $Id: hb_8.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: hb_8.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: hb_8.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + */ + +#include "hb.h" + +static const R *hb_8(R *rio, R *iio, const R *W, stride ios, int m, int dist) +{ + DK(KP707106781, +0.707106781186547524400844362104849039284835938); + int i; + for (i = m - 2; i > 0; i = i - 2, rio = rio + dist, iio = iio - dist, W = W + 14) { + E T7, T18, T1d, Tg, Tx, TT, TY, TG, Te, TZ, T10, Tn, Tq, TM, TP; + E TH; + { + E T3, TR, Tt, TX, T6, TW, Tw, TS; + { + E T1, T2, Tr, Ts; + T1 = rio[0]; + T2 = iio[-WS(ios, 4)]; + T3 = T1 + T2; + TR = T1 - T2; + Tr = iio[0]; + Ts = rio[WS(ios, 4)]; + Tt = Tr - Ts; + TX = Tr + Ts; + } + { + E T4, T5, Tu, Tv; + T4 = rio[WS(ios, 2)]; + T5 = iio[-WS(ios, 6)]; + T6 = T4 + T5; + TW = T4 - T5; + Tu = iio[-WS(ios, 2)]; + Tv = rio[WS(ios, 6)]; + Tw = Tu - Tv; + TS = Tu + Tv; + } + T7 = T3 + T6; + T18 = TX - TW; + T1d = TR + TS; + Tg = T3 - T6; + Tx = Tt - Tw; + TT = TR - TS; + TY = TW + TX; + TG = Tt + Tw; + } + { + E Ta, TO, Tj, TN, Td, TK, Tm, TL; + { + E T8, T9, Th, Ti; + T8 = rio[WS(ios, 1)]; + T9 = iio[-WS(ios, 5)]; + Ta = T8 + T9; + TO = T8 - T9; + Th = iio[-WS(ios, 1)]; + Ti = rio[WS(ios, 5)]; + Tj = Th - Ti; + TN = Th + Ti; + } + { + E Tb, Tc, Tk, Tl; + Tb = iio[-WS(ios, 7)]; + Tc = rio[WS(ios, 3)]; + Td = Tb + Tc; + TK = Tb - Tc; + Tk = iio[-WS(ios, 3)]; + Tl = rio[WS(ios, 7)]; + Tm = Tk - Tl; + TL = Tl + Tk; + } + Te = Ta + Td; + TZ = TO + TN; + T10 = TK + TL; + Tn = Tj - Tm; + Tq = Td - Ta; + TM = TK - TL; + TP = TN - TO; + TH = Tj + Tm; + } + rio[0] = T7 + Te; + iio[-WS(ios, 7)] = TH + TG; + { + E To, Ty, Tf, Tp; + To = Tg + Tn; + Ty = Tq + Tx; + Tf = W[10]; + Tp = W[11]; + rio[WS(ios, 6)] = FNMS(Tp, Ty, Tf * To); + iio[-WS(ios, 1)] = FMA(Tp, To, Tf * Ty); + } + { + E TE, TI, TD, TF; + TE = T7 - Te; + TI = TG - TH; + TD = W[6]; + TF = W[7]; + rio[WS(ios, 4)] = FNMS(TF, TI, TD * TE); + iio[-WS(ios, 3)] = FMA(TF, TE, TD * TI); + } + { + E TA, TC, Tz, TB; + TA = Tg - Tn; + TC = Tx - Tq; + Tz = W[2]; + TB = W[3]; + rio[WS(ios, 2)] = FNMS(TB, TC, Tz * TA); + iio[-WS(ios, 5)] = FMA(TB, TA, Tz * TC); + } + { + E TU, T16, T12, T14, TQ, T11; + TQ = KP707106781 * (TM - TP); + TU = TQ + TT; + T16 = TT - TQ; + T11 = KP707106781 * (TZ - T10); + T12 = TY + T11; + T14 = TY - T11; + { + E TJ, TV, T13, T15; + TJ = W[0]; + TV = W[1]; + rio[WS(ios, 1)] = FNMS(TV, T12, TJ * TU); + iio[-WS(ios, 6)] = FMA(TJ, T12, TV * TU); + T13 = W[8]; + T15 = W[9]; + iio[-WS(ios, 2)] = FMA(T13, T14, T15 * T16); + rio[WS(ios, 5)] = FNMS(T15, T14, T13 * T16); + } + } + { + E T1a, T1i, T1e, T1g, T19, T1c; + T19 = KP707106781 * (TP + TM); + T1a = T18 + T19; + T1i = T18 - T19; + T1c = KP707106781 * (TZ + T10); + T1e = T1c + T1d; + T1g = T1d - T1c; + { + E T17, T1b, T1f, T1h; + T17 = W[12]; + T1b = W[13]; + iio[0] = FMA(T17, T1a, T1b * T1e); + rio[WS(ios, 7)] = FNMS(T1b, T1a, T17 * T1e); + T1f = W[4]; + T1h = W[5]; + rio[WS(ios, 3)] = FNMS(T1h, T1i, T1f * T1g); + iio[-WS(ios, 4)] = FMA(T1f, T1i, T1h * T1g); + } + } + } + return W; +} + +static const tw_instr twinstr[] = { + {TW_FULL, 0, 8}, + {TW_NEXT, 1, 0} +}; + +static const hc2hc_desc desc = { 8, "hb_8", twinstr, {52, 18, 14, 0}, &GENUS, 0, 0, 0 }; + +void X(codelet_hb_8) (planner *p) { + X(khc2hc_dif_register) (p, hb_8, &desc); +} diff --git a/src/fftw3/rdft/codelets/hc2r/hb_9.c b/src/fftw3/rdft/codelets/hc2r/hb_9.c new file mode 100644 index 0000000..ed3eb98 --- /dev/null +++ b/src/fftw3/rdft/codelets/hc2r/hb_9.c @@ -0,0 +1,248 @@ +/* + * Copyright (c) 2003 Matteo Frigo + * Copyright (c) 2003 Massachusetts Institute of Technology + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +/* This file was automatically generated --- DO NOT EDIT */ +/* Generated on Sat Jul 5 22:11:31 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_hc2hc -compact -variables 4 -sign 1 -n 9 -dif -name hb_9 -include hb.h */ + +/* + * This function contains 96 FP additions, 72 FP multiplications, + * (or, 60 additions, 36 multiplications, 36 fused multiply/add), + * 53 stack variables, and 36 memory accesses + */ +/* + * Generator Id's : + * $Id: hb_9.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: hb_9.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: hb_9.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + */ + +#include "hb.h" + +static const R *hb_9(R *rio, R *iio, const R *W, stride ios, int m, int dist) +{ + DK(KP642787609, +0.642787609686539326322643409907263432907559884); + DK(KP766044443, +0.766044443118978035202392650555416673935832457); + DK(KP984807753, +0.984807753012208059366743024589523013670643252); + DK(KP173648177, +0.173648177666930348851716626769314796000375677); + DK(KP342020143, +0.342020143325668733044099614682259580763083368); + DK(KP939692620, +0.939692620785908384054109277324731469936208134); + DK(KP500000000, +0.500000000000000000000000000000000000000000000); + DK(KP866025403, +0.866025403784438646763723170752936183471402627); + int i; + for (i = m - 2; i > 0; i = i - 2, rio = rio + dist, iio = iio - dist, W = W + 16) { + E T5, T1z, Tm, T18, TQ, T1i, Ta, Tf, Tg, T1A, T1B, T1C, Tx, TS, T1e; + E T1k, T1b, T1j, TI, TR; + { + E T1, TM, T4, TP, Tl, TN, Ti, TO; + T1 = rio[0]; + TM = iio[0]; + { + E T2, T3, Tj, Tk; + T2 = rio[WS(ios, 3)]; + T3 = iio[-WS(ios, 6)]; + T4 = T2 + T3; + TP = KP866025403 * (T2 - T3); + Tj = rio[WS(ios, 6)]; + Tk = iio[-WS(ios, 3)]; + Tl = KP866025403 * (Tj + Tk); + TN = Tj - Tk; + } + T5 = T1 + T4; + T1z = TM - TN; + Ti = FNMS(KP500000000, T4, T1); + Tm = Ti + Tl; + T18 = Ti - Tl; + TO = FMA(KP500000000, TN, TM); + TQ = TO - TP; + T1i = TP + TO; + } + { + E T6, T9, Ty, TG, TD, TE, TB, TF, Tb, Te, Tn, Tv, Tt, Ts, Tq; + E Tu; + { + E T7, T8, Tz, TA; + T6 = rio[WS(ios, 1)]; + T7 = rio[WS(ios, 4)]; + T8 = iio[-WS(ios, 7)]; + T9 = T7 + T8; + Ty = FNMS(KP500000000, T9, T6); + TG = KP866025403 * (T7 - T8); + TD = iio[-WS(ios, 1)]; + Tz = rio[WS(ios, 7)]; + TA = iio[-WS(ios, 4)]; + TE = Tz - TA; + TB = KP866025403 * (Tz + TA); + TF = FMA(KP500000000, TE, TD); + } + { + E Tc, Td, To, Tp; + Tb = rio[WS(ios, 2)]; + Tc = iio[-WS(ios, 5)]; + Td = iio[-WS(ios, 8)]; + Te = Tc + Td; + Tn = FNMS(KP500000000, Te, Tb); + Tv = KP866025403 * (Tc - Td); + Tt = iio[-WS(ios, 2)]; + To = rio[WS(ios, 5)]; + Tp = rio[WS(ios, 8)]; + Ts = To + Tp; + Tq = KP866025403 * (To - Tp); + Tu = FMA(KP500000000, Ts, Tt); + } + { + E Tr, Tw, T1c, T1d; + Ta = T6 + T9; + Tf = Tb + Te; + Tg = Ta + Tf; + T1A = TD - TE; + T1B = Tt - Ts; + T1C = T1A + T1B; + Tr = Tn - Tq; + Tw = Tu - Tv; + Tx = FMA(KP939692620, Tr, KP342020143 * Tw); + TS = FNMS(KP939692620, Tw, KP342020143 * Tr); + T1c = Tn + Tq; + T1d = Tv + Tu; + T1e = FNMS(KP984807753, T1d, KP173648177 * T1c); + T1k = FMA(KP984807753, T1c, KP173648177 * T1d); + { + E T19, T1a, TC, TH; + T19 = Ty - TB; + T1a = TG + TF; + T1b = FNMS(KP642787609, T1a, KP766044443 * T19); + T1j = FMA(KP766044443, T1a, KP642787609 * T19); + TC = Ty + TB; + TH = TF - TG; + TI = FNMS(KP984807753, TH, KP173648177 * TC); + TR = FMA(KP173648177, TH, KP984807753 * TC); + } + } + } + rio[0] = T5 + Tg; + { + E TX, T11, TK, T10, TU, TW, TJ, TT, Th, TL; + TX = KP866025403 * (TI + Tx); + T11 = KP866025403 * (TS - TR); + TJ = Tx - TI; + TK = Tm - TJ; + T10 = FMA(KP500000000, TJ, Tm); + TT = TR + TS; + TU = TQ + TT; + TW = FNMS(KP500000000, TT, TQ); + Th = W[2]; + TL = W[3]; + rio[WS(ios, 2)] = FNMS(TL, TU, Th * TK); + iio[-WS(ios, 6)] = FMA(Th, TU, TL * TK); + { + E T14, T16, T13, T15; + T14 = TW + TX; + T16 = T11 + T10; + T13 = W[8]; + T15 = W[9]; + iio[-WS(ios, 3)] = FMA(T13, T14, T15 * T16); + rio[WS(ios, 5)] = FNMS(T15, T14, T13 * T16); + } + { + E TY, T12, TV, TZ; + TY = TW - TX; + T12 = T10 - T11; + TV = W[14]; + TZ = W[15]; + iio[0] = FMA(TV, TY, TZ * T12); + rio[WS(ios, 8)] = FNMS(TZ, TY, TV * T12); + } + } + iio[-WS(ios, 8)] = T1z + T1C; + { + E T1G, T1O, T1K, T1M; + { + E T1E, T1F, T1I, T1J; + T1E = FNMS(KP500000000, T1C, T1z); + T1F = KP866025403 * (Ta - Tf); + T1G = T1E - T1F; + T1O = T1F + T1E; + T1I = FNMS(KP500000000, Tg, T5); + T1J = KP866025403 * (T1B - T1A); + T1K = T1I - T1J; + T1M = T1I + T1J; + } + { + E T1D, T1H, T1L, T1N; + T1D = W[10]; + T1H = W[11]; + iio[-WS(ios, 2)] = FMA(T1D, T1G, T1H * T1K); + rio[WS(ios, 6)] = FNMS(T1H, T1G, T1D * T1K); + T1L = W[4]; + T1N = W[5]; + rio[WS(ios, 3)] = FNMS(T1N, T1O, T1L * T1M); + iio[-WS(ios, 5)] = FMA(T1L, T1O, T1N * T1M); + } + } + { + E T1p, T1t, T1g, T1s, T1m, T1o, T1f, T1l, T17, T1h; + T1p = KP866025403 * (T1b - T1e); + T1t = KP866025403 * (T1k - T1j); + T1f = T1b + T1e; + T1g = T18 + T1f; + T1s = FNMS(KP500000000, T1f, T18); + T1l = T1j + T1k; + T1m = T1i + T1l; + T1o = FNMS(KP500000000, T1l, T1i); + T17 = W[0]; + T1h = W[1]; + rio[WS(ios, 1)] = FNMS(T1h, T1m, T17 * T1g); + iio[-WS(ios, 7)] = FMA(T1h, T1g, T17 * T1m); + { + E T1q, T1u, T1n, T1r; + T1q = T1o - T1p; + T1u = T1s - T1t; + T1n = W[12]; + T1r = W[13]; + iio[-WS(ios, 1)] = FMA(T1n, T1q, T1r * T1u); + rio[WS(ios, 7)] = FNMS(T1r, T1q, T1n * T1u); + } + { + E T1w, T1y, T1v, T1x; + T1w = T1s + T1t; + T1y = T1p + T1o; + T1v = W[6]; + T1x = W[7]; + rio[WS(ios, 4)] = FNMS(T1x, T1y, T1v * T1w); + iio[-WS(ios, 4)] = FMA(T1v, T1y, T1x * T1w); + } + } + } + return W; +} + +static const tw_instr twinstr[] = { + {TW_FULL, 0, 9}, + {TW_NEXT, 1, 0} +}; + +static const hc2hc_desc desc = { 9, "hb_9", twinstr, {60, 36, 36, 0}, &GENUS, 0, 0, 0 }; + +void X(codelet_hb_9) (planner *p) { + X(khc2hc_dif_register) (p, hb_9, &desc); +} diff --git a/src/fftw3/rdft/codelets/hc2r/hc2rIII_10.c b/src/fftw3/rdft/codelets/hc2r/hc2rIII_10.c new file mode 100644 index 0000000..df8c872 --- /dev/null +++ b/src/fftw3/rdft/codelets/hc2r/hc2rIII_10.c @@ -0,0 +1,113 @@ +/* + * Copyright (c) 2003 Matteo Frigo + * Copyright (c) 2003 Massachusetts Institute of Technology + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +/* This file was automatically generated --- DO NOT EDIT */ +/* Generated on Sat Jul 5 22:12:05 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_hc2r -compact -variables 4 -sign 1 -n 10 -name hc2rIII_10 -dft-III -include hc2rIII.h */ + +/* + * This function contains 32 FP additions, 16 FP multiplications, + * (or, 26 additions, 10 multiplications, 6 fused multiply/add), + * 22 stack variables, and 20 memory accesses + */ +/* + * Generator Id's : + * $Id: hc2rIII_10.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: hc2rIII_10.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: hc2rIII_10.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + */ + +#include "hc2rIII.h" + +static void hc2rIII_10(const R *ri, const R *ii, R *O, stride ris, stride iis, stride os, int v, int ivs, int ovs) +{ + DK(KP500000000, +0.500000000000000000000000000000000000000000000); + DK(KP1_902113032, +1.902113032590307144232878666758764286811397268); + DK(KP1_175570504, +1.175570504584946258337411909278145537195304875); + DK(KP2_000000000, +2.000000000000000000000000000000000000000000000); + DK(KP1_118033988, +1.118033988749894848204586834365638117720309180); + int i; + for (i = v; i > 0; i = i - 1, ri = ri + ivs, ii = ii + ivs, O = O + ovs) { + E T1, To, T8, Tq, Ta, Tp, Te, Ts, Th, Tn; + T1 = ri[WS(ris, 2)]; + To = ii[WS(iis, 2)]; + { + E T2, T3, T4, T5, T6, T7; + T2 = ri[WS(ris, 4)]; + T3 = ri[0]; + T4 = T2 + T3; + T5 = ri[WS(ris, 3)]; + T6 = ri[WS(ris, 1)]; + T7 = T5 + T6; + T8 = T4 + T7; + Tq = T5 - T6; + Ta = KP1_118033988 * (T7 - T4); + Tp = T2 - T3; + } + { + E Tc, Td, Tm, Tf, Tg, Tl; + Tc = ii[WS(iis, 4)]; + Td = ii[0]; + Tm = Tc + Td; + Tf = ii[WS(iis, 1)]; + Tg = ii[WS(iis, 3)]; + Tl = Tg + Tf; + Te = Tc - Td; + Ts = KP1_118033988 * (Tl + Tm); + Th = Tf - Tg; + Tn = Tl - Tm; + } + O[0] = KP2_000000000 * (T1 + T8); + O[WS(os, 5)] = KP2_000000000 * (Tn - To); + { + E Ti, Tj, Tb, Tk, T9; + Ti = FNMS(KP1_902113032, Th, KP1_175570504 * Te); + Tj = FMA(KP1_175570504, Th, KP1_902113032 * Te); + T9 = FNMS(KP2_000000000, T1, KP500000000 * T8); + Tb = T9 - Ta; + Tk = T9 + Ta; + O[WS(os, 2)] = Tb + Ti; + O[WS(os, 6)] = Tk + Tj; + O[WS(os, 8)] = Ti - Tb; + O[WS(os, 4)] = Tj - Tk; + } + { + E Tr, Tv, Tu, Tw, Tt; + Tr = FMA(KP1_902113032, Tp, KP1_175570504 * Tq); + Tv = FNMS(KP1_175570504, Tp, KP1_902113032 * Tq); + Tt = FMA(KP500000000, Tn, KP2_000000000 * To); + Tu = Ts + Tt; + Tw = Tt - Ts; + O[WS(os, 1)] = -(Tr + Tu); + O[WS(os, 7)] = Tw - Tv; + O[WS(os, 9)] = Tr - Tu; + O[WS(os, 3)] = Tv + Tw; + } + } +} + +static const khc2r_desc desc = { 10, "hc2rIII_10", {26, 10, 6, 0}, &GENUS, 0, 0, 0, 0, 0 }; + +void X(codelet_hc2rIII_10) (planner *p) { + X(khc2rIII_register) (p, hc2rIII_10, &desc); +} diff --git a/src/fftw3/rdft/codelets/hc2r/hc2rIII_12.c b/src/fftw3/rdft/codelets/hc2r/hc2rIII_12.c new file mode 100644 index 0000000..0a36bf0 --- /dev/null +++ b/src/fftw3/rdft/codelets/hc2r/hc2rIII_12.c @@ -0,0 +1,130 @@ +/* + * Copyright (c) 2003 Matteo Frigo + * Copyright (c) 2003 Massachusetts Institute of Technology + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +/* This file was automatically generated --- DO NOT EDIT */ +/* Generated on Sat Jul 5 22:12:07 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_hc2r -compact -variables 4 -sign 1 -n 12 -name hc2rIII_12 -dft-III -include hc2rIII.h */ + +/* + * This function contains 42 FP additions, 20 FP multiplications, + * (or, 38 additions, 16 multiplications, 4 fused multiply/add), + * 25 stack variables, and 24 memory accesses + */ +/* + * Generator Id's : + * $Id: hc2rIII_12.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: hc2rIII_12.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: hc2rIII_12.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + */ + +#include "hc2rIII.h" + +static void hc2rIII_12(const R *ri, const R *ii, R *O, stride ris, stride iis, stride os, int v, int ivs, int ovs) +{ + DK(KP1_414213562, +1.414213562373095048801688724209698078569671875); + DK(KP2_000000000, +2.000000000000000000000000000000000000000000000); + DK(KP500000000, +0.500000000000000000000000000000000000000000000); + DK(KP866025403, +0.866025403784438646763723170752936183471402627); + int i; + for (i = v; i > 0; i = i - 1, ri = ri + ivs, ii = ii + ivs, O = O + ovs) { + E T5, Tw, Tb, Te, Tx, Ts, Ta, TA, Tg, Tj, Tz, Tp, Tt, Tu; + { + E T1, T2, T3, T4; + T1 = ri[WS(ris, 1)]; + T2 = ri[WS(ris, 5)]; + T3 = ri[WS(ris, 2)]; + T4 = T2 + T3; + T5 = T1 + T4; + Tw = KP866025403 * (T2 - T3); + Tb = FNMS(KP500000000, T4, T1); + } + { + E Tq, Tc, Td, Tr; + Tq = ii[WS(iis, 1)]; + Tc = ii[WS(iis, 5)]; + Td = ii[WS(iis, 2)]; + Tr = Td - Tc; + Te = KP866025403 * (Tc + Td); + Tx = FMA(KP500000000, Tr, Tq); + Ts = Tq - Tr; + } + { + E T6, T7, T8, T9; + T6 = ri[WS(ris, 4)]; + T7 = ri[0]; + T8 = ri[WS(ris, 3)]; + T9 = T7 + T8; + Ta = T6 + T9; + TA = KP866025403 * (T7 - T8); + Tg = FNMS(KP500000000, T9, T6); + } + { + E To, Th, Ti, Tn; + To = ii[WS(iis, 4)]; + Th = ii[0]; + Ti = ii[WS(iis, 3)]; + Tn = Ti - Th; + Tj = KP866025403 * (Th + Ti); + Tz = FMA(KP500000000, Tn, To); + Tp = Tn - To; + } + O[0] = KP2_000000000 * (T5 + Ta); + O[WS(os, 6)] = KP2_000000000 * (Ts + Tp); + Tt = Tp - Ts; + Tu = T5 - Ta; + O[WS(os, 3)] = KP1_414213562 * (Tt - Tu); + O[WS(os, 9)] = KP1_414213562 * (Tu + Tt); + { + E Tf, Tk, Tv, Ty, TB, TC; + Tf = Tb - Te; + Tk = Tg + Tj; + Tv = Tf - Tk; + Ty = Tw + Tx; + TB = Tz - TA; + TC = Ty + TB; + O[WS(os, 4)] = -(KP2_000000000 * (Tf + Tk)); + O[WS(os, 10)] = KP2_000000000 * (TB - Ty); + O[WS(os, 1)] = KP1_414213562 * (Tv - TC); + O[WS(os, 7)] = KP1_414213562 * (Tv + TC); + } + { + E Tl, Tm, TF, TD, TE, TG; + Tl = Tb + Te; + Tm = Tg - Tj; + TF = Tm - Tl; + TD = TA + Tz; + TE = Tx - Tw; + TG = TE + TD; + O[WS(os, 8)] = KP2_000000000 * (Tl + Tm); + O[WS(os, 5)] = KP1_414213562 * (TF + TG); + O[WS(os, 2)] = KP2_000000000 * (TD - TE); + O[WS(os, 11)] = KP1_414213562 * (TF - TG); + } + } +} + +static const khc2r_desc desc = { 12, "hc2rIII_12", {38, 16, 4, 0}, &GENUS, 0, 0, 0, 0, 0 }; + +void X(codelet_hc2rIII_12) (planner *p) { + X(khc2rIII_register) (p, hc2rIII_12, &desc); +} diff --git a/src/fftw3/rdft/codelets/hc2r/hc2rIII_15.c b/src/fftw3/rdft/codelets/hc2r/hc2rIII_15.c new file mode 100644 index 0000000..9a94a9a --- /dev/null +++ b/src/fftw3/rdft/codelets/hc2r/hc2rIII_15.c @@ -0,0 +1,169 @@ +/* + * Copyright (c) 2003 Matteo Frigo + * Copyright (c) 2003 Massachusetts Institute of Technology + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +/* This file was automatically generated --- DO NOT EDIT */ +/* Generated on Sat Jul 5 22:12:11 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_hc2r -compact -variables 4 -sign 1 -n 15 -name hc2rIII_15 -dft-III -include hc2rIII.h */ + +/* + * This function contains 64 FP additions, 26 FP multiplications, + * (or, 49 additions, 11 multiplications, 15 fused multiply/add), + * 47 stack variables, and 30 memory accesses + */ +/* + * Generator Id's : + * $Id: hc2rIII_15.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: hc2rIII_15.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: hc2rIII_15.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + */ + +#include "hc2rIII.h" + +static void hc2rIII_15(const R *ri, const R *ii, R *O, stride ris, stride iis, stride os, int v, int ivs, int ovs) +{ + DK(KP1_732050807, +1.732050807568877293527446341505872366942805254); + DK(KP433012701, +0.433012701892219323381861585376468091735701313); + DK(KP968245836, +0.968245836551854221294816349945599902708230426); + DK(KP587785252, +0.587785252292473129168705954639072768597652438); + DK(KP951056516, +0.951056516295153572116439333379382143405698634); + DK(KP250000000, +0.250000000000000000000000000000000000000000000); + DK(KP1_647278207, +1.647278207092663851754840078556380006059321028); + DK(KP1_018073920, +1.018073920910254366901961726787815297021466329); + DK(KP559016994, +0.559016994374947424102293417182819058860154590); + DK(KP500000000, +0.500000000000000000000000000000000000000000000); + DK(KP2_000000000, +2.000000000000000000000000000000000000000000000); + DK(KP1_118033988, +1.118033988749894848204586834365638117720309180); + DK(KP1_175570504, +1.175570504584946258337411909278145537195304875); + DK(KP1_902113032, +1.902113032590307144232878666758764286811397268); + int i; + for (i = v; i > 0; i = i - 1, ri = ri + ivs, ii = ii + ivs, O = O + ovs) { + E Tv, TD, T5, Ts, TC, T6, Tf, TW, TK, Td, Tg, TP, To, TN, TA; + E TO, TQ, Tt, Tu, T12, Te, T11; + Tt = ii[WS(iis, 4)]; + Tu = ii[WS(iis, 1)]; + Tv = FMA(KP1_902113032, Tt, KP1_175570504 * Tu); + TD = FNMS(KP1_175570504, Tt, KP1_902113032 * Tu); + { + E T1, T4, Tq, T2, T3, Tr; + T1 = ri[WS(ris, 7)]; + T2 = ri[WS(ris, 4)]; + T3 = ri[WS(ris, 1)]; + T4 = T2 + T3; + Tq = KP1_118033988 * (T2 - T3); + T5 = FMA(KP2_000000000, T4, T1); + Tr = FNMS(KP500000000, T4, T1); + Ts = Tq + Tr; + TC = Tr - Tq; + } + { + E Tc, TJ, T9, TI; + T6 = ri[WS(ris, 2)]; + { + E Ta, Tb, T7, T8; + Ta = ri[WS(ris, 3)]; + Tb = ri[WS(ris, 6)]; + Tc = Ta + Tb; + TJ = Ta - Tb; + T7 = ri[0]; + T8 = ri[WS(ris, 5)]; + T9 = T7 + T8; + TI = T7 - T8; + } + Tf = KP559016994 * (T9 - Tc); + TW = FNMS(KP1_647278207, TJ, KP1_018073920 * TI); + TK = FMA(KP1_647278207, TI, KP1_018073920 * TJ); + Td = T9 + Tc; + Tg = FNMS(KP250000000, Td, T6); + } + { + E Tn, TM, Tk, TL; + TP = ii[WS(iis, 2)]; + { + E Tl, Tm, Ti, Tj; + Tl = ii[WS(iis, 3)]; + Tm = ii[WS(iis, 6)]; + Tn = Tl - Tm; + TM = Tl + Tm; + Ti = ii[0]; + Tj = ii[WS(iis, 5)]; + Tk = Ti + Tj; + TL = Ti - Tj; + } + To = FMA(KP951056516, Tk, KP587785252 * Tn); + TN = KP968245836 * (TL - TM); + TA = FNMS(KP587785252, Tk, KP951056516 * Tn); + TO = TL + TM; + TQ = FMA(KP433012701, TO, KP1_732050807 * TP); + } + T12 = KP1_732050807 * (TP - TO); + Te = T6 + Td; + T11 = Te - T5; + O[0] = FMA(KP2_000000000, Te, T5); + O[WS(os, 10)] = T12 - T11; + O[WS(os, 5)] = T11 + T12; + { + E TE, TG, TB, TF, TY, T10, Tz, TX, TV, TZ; + TE = TC - TD; + TG = TC + TD; + Tz = Tg - Tf; + TB = Tz + TA; + TF = TA - Tz; + TX = TN + TQ; + TY = TW - TX; + T10 = TW + TX; + O[WS(os, 12)] = FMA(KP2_000000000, TB, TE); + O[WS(os, 3)] = FMS(KP2_000000000, TF, TG); + TV = TE - TB; + O[WS(os, 2)] = TV + TY; + O[WS(os, 7)] = TY - TV; + TZ = TF + TG; + O[WS(os, 8)] = TZ - T10; + O[WS(os, 13)] = -(TZ + T10); + } + { + E Tw, Ty, Tp, Tx, TS, TU, Th, TR, TH, TT; + Tw = Ts - Tv; + Ty = Ts + Tv; + Th = Tf + Tg; + Tp = Th + To; + Tx = Th - To; + TR = TN - TQ; + TS = TK + TR; + TU = TR - TK; + O[WS(os, 9)] = -(FMA(KP2_000000000, Tp, Tw)); + O[WS(os, 6)] = FMA(KP2_000000000, Tx, Ty); + TH = Tx - Ty; + O[WS(os, 11)] = TH - TS; + O[WS(os, 1)] = TH + TS; + TT = Tw - Tp; + O[WS(os, 4)] = TT - TU; + O[WS(os, 14)] = TT + TU; + } + } +} + +static const khc2r_desc desc = { 15, "hc2rIII_15", {49, 11, 15, 0}, &GENUS, 0, 0, 0, 0, 0 }; + +void X(codelet_hc2rIII_15) (planner *p) { + X(khc2rIII_register) (p, hc2rIII_15, &desc); +} diff --git a/src/fftw3/rdft/codelets/hc2r/hc2rIII_16.c b/src/fftw3/rdft/codelets/hc2r/hc2rIII_16.c new file mode 100644 index 0000000..a81a4a1 --- /dev/null +++ b/src/fftw3/rdft/codelets/hc2r/hc2rIII_16.c @@ -0,0 +1,173 @@ +/* + * Copyright (c) 2003 Matteo Frigo + * Copyright (c) 2003 Massachusetts Institute of Technology + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +/* This file was automatically generated --- DO NOT EDIT */ +/* Generated on Sat Jul 5 22:12:13 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_hc2r -compact -variables 4 -sign 1 -n 16 -name hc2rIII_16 -dft-III -include hc2rIII.h */ + +/* + * This function contains 66 FP additions, 32 FP multiplications, + * (or, 54 additions, 20 multiplications, 12 fused multiply/add), + * 40 stack variables, and 32 memory accesses + */ +/* + * Generator Id's : + * $Id: hc2rIII_16.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: hc2rIII_16.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: hc2rIII_16.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + */ + +#include "hc2rIII.h" + +static void hc2rIII_16(const R *ri, const R *ii, R *O, stride ris, stride iis, stride os, int v, int ivs, int ovs) +{ + DK(KP1_961570560, +1.961570560806460898252364472268478073947867462); + DK(KP390180644, +0.390180644032256535696569736954044481855383236); + DK(KP1_111140466, +1.111140466039204449485661627897065748749874382); + DK(KP1_662939224, +1.662939224605090474157576755235811513477121624); + DK(KP707106781, +0.707106781186547524400844362104849039284835938); + DK(KP1_414213562, +1.414213562373095048801688724209698078569671875); + DK(KP765366864, +0.765366864730179543456919968060797733522689125); + DK(KP1_847759065, +1.847759065022573512256366378793576573644833252); + DK(KP2_000000000, +2.000000000000000000000000000000000000000000000); + int i; + for (i = v; i > 0; i = i - 1, ri = ri + ivs, ii = ii + ivs, O = O + ovs) { + E T7, TW, T13, Tj, TD, TK, TP, TH, Te, TX, T12, To, Tt, Tx, TS; + E Tw, TT, TY; + { + E T3, Tf, TC, TV, T6, Tz, Ti, TU; + { + E T1, T2, TA, TB; + T1 = ri[0]; + T2 = ri[WS(ris, 7)]; + T3 = T1 + T2; + Tf = T1 - T2; + TA = ii[0]; + TB = ii[WS(iis, 7)]; + TC = TA + TB; + TV = TB - TA; + } + { + E T4, T5, Tg, Th; + T4 = ri[WS(ris, 4)]; + T5 = ri[WS(ris, 3)]; + T6 = T4 + T5; + Tz = T4 - T5; + Tg = ii[WS(iis, 4)]; + Th = ii[WS(iis, 3)]; + Ti = Tg + Th; + TU = Tg - Th; + } + T7 = T3 + T6; + TW = TU + TV; + T13 = TV - TU; + Tj = Tf - Ti; + TD = Tz + TC; + TK = Tz - TC; + TP = T3 - T6; + TH = Tf + Ti; + } + { + E Ta, Tk, Tn, TR, Td, Tp, Ts, TQ; + { + E T8, T9, Tl, Tm; + T8 = ri[WS(ris, 2)]; + T9 = ri[WS(ris, 5)]; + Ta = T8 + T9; + Tk = T8 - T9; + Tl = ii[WS(iis, 2)]; + Tm = ii[WS(iis, 5)]; + Tn = Tl + Tm; + TR = Tl - Tm; + } + { + E Tb, Tc, Tq, Tr; + Tb = ri[WS(ris, 1)]; + Tc = ri[WS(ris, 6)]; + Td = Tb + Tc; + Tp = Tb - Tc; + Tq = ii[WS(iis, 1)]; + Tr = ii[WS(iis, 6)]; + Ts = Tq + Tr; + TQ = Tr - Tq; + } + Te = Ta + Td; + TX = Ta - Td; + T12 = TR + TQ; + To = Tk - Tn; + Tt = Tp - Ts; + Tx = Tp + Ts; + TS = TQ - TR; + Tw = Tk + Tn; + } + O[0] = KP2_000000000 * (T7 + Te); + O[WS(os, 8)] = KP2_000000000 * (T13 - T12); + TT = TP + TS; + TY = TW - TX; + O[WS(os, 2)] = FMA(KP1_847759065, TT, KP765366864 * TY); + O[WS(os, 10)] = FNMS(KP765366864, TT, KP1_847759065 * TY); + { + E T11, T14, TZ, T10; + T11 = T7 - Te; + T14 = T12 + T13; + O[WS(os, 4)] = KP1_414213562 * (T11 + T14); + O[WS(os, 12)] = KP1_414213562 * (T14 - T11); + TZ = TP - TS; + T10 = TX + TW; + O[WS(os, 6)] = FMA(KP765366864, TZ, KP1_847759065 * T10); + O[WS(os, 14)] = FNMS(KP1_847759065, TZ, KP765366864 * T10); + } + { + E TJ, TN, TM, TO, TI, TL; + TI = KP707106781 * (Tw + Tx); + TJ = TH - TI; + TN = TH + TI; + TL = KP707106781 * (To - Tt); + TM = TK - TL; + TO = TL + TK; + O[WS(os, 3)] = FMA(KP1_662939224, TJ, KP1_111140466 * TM); + O[WS(os, 15)] = FNMS(KP1_961570560, TN, KP390180644 * TO); + O[WS(os, 11)] = FNMS(KP1_111140466, TJ, KP1_662939224 * TM); + O[WS(os, 7)] = FMA(KP390180644, TN, KP1_961570560 * TO); + } + { + E Tv, TF, TE, TG, Tu, Ty; + Tu = KP707106781 * (To + Tt); + Tv = Tj + Tu; + TF = Tj - Tu; + Ty = KP707106781 * (Tw - Tx); + TE = Ty + TD; + TG = Ty - TD; + O[WS(os, 1)] = FNMS(KP390180644, TE, KP1_961570560 * Tv); + O[WS(os, 13)] = FNMS(KP1_662939224, TF, KP1_111140466 * TG); + O[WS(os, 9)] = -(FMA(KP390180644, Tv, KP1_961570560 * TE)); + O[WS(os, 5)] = FMA(KP1_111140466, TF, KP1_662939224 * TG); + } + } +} + +static const khc2r_desc desc = { 16, "hc2rIII_16", {54, 20, 12, 0}, &GENUS, 0, 0, 0, 0, 0 }; + +void X(codelet_hc2rIII_16) (planner *p) { + X(khc2rIII_register) (p, hc2rIII_16, &desc); +} diff --git a/src/fftw3/rdft/codelets/hc2r/hc2rIII_2.c b/src/fftw3/rdft/codelets/hc2r/hc2rIII_2.c new file mode 100644 index 0000000..c01ed70 --- /dev/null +++ b/src/fftw3/rdft/codelets/hc2r/hc2rIII_2.c @@ -0,0 +1,59 @@ +/* + * Copyright (c) 2003 Matteo Frigo + * Copyright (c) 2003 Massachusetts Institute of Technology + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +/* This file was automatically generated --- DO NOT EDIT */ +/* Generated on Sat Jul 5 22:11:54 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_hc2r -compact -variables 4 -sign 1 -n 2 -name hc2rIII_2 -dft-III -include hc2rIII.h */ + +/* + * This function contains 0 FP additions, 2 FP multiplications, + * (or, 0 additions, 2 multiplications, 0 fused multiply/add), + * 4 stack variables, and 4 memory accesses + */ +/* + * Generator Id's : + * $Id: hc2rIII_2.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: hc2rIII_2.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: hc2rIII_2.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + */ + +#include "hc2rIII.h" + +static void hc2rIII_2(const R *ri, const R *ii, R *O, stride ris, stride iis, stride os, int v, int ivs, int ovs) +{ + DK(KP2_000000000, +2.000000000000000000000000000000000000000000000); + int i; + for (i = v; i > 0; i = i - 1, ri = ri + ivs, ii = ii + ivs, O = O + ovs) { + E T1, T2; + T1 = ri[0]; + O[0] = KP2_000000000 * T1; + T2 = ii[0]; + O[WS(os, 1)] = -(KP2_000000000 * T2); + } +} + +static const khc2r_desc desc = { 2, "hc2rIII_2", {0, 2, 0, 0}, &GENUS, 0, 0, 0, 0, 0 }; + +void X(codelet_hc2rIII_2) (planner *p) { + X(khc2rIII_register) (p, hc2rIII_2, &desc); +} diff --git a/src/fftw3/rdft/codelets/hc2r/hc2rIII_3.c b/src/fftw3/rdft/codelets/hc2r/hc2rIII_3.c new file mode 100644 index 0000000..05b761d --- /dev/null +++ b/src/fftw3/rdft/codelets/hc2r/hc2rIII_3.c @@ -0,0 +1,64 @@ +/* + * Copyright (c) 2003 Matteo Frigo + * Copyright (c) 2003 Massachusetts Institute of Technology + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +/* This file was automatically generated --- DO NOT EDIT */ +/* Generated on Sat Jul 5 22:11:54 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_hc2r -compact -variables 4 -sign 1 -n 3 -name hc2rIII_3 -dft-III -include hc2rIII.h */ + +/* + * This function contains 4 FP additions, 2 FP multiplications, + * (or, 3 additions, 1 multiplications, 1 fused multiply/add), + * 8 stack variables, and 6 memory accesses + */ +/* + * Generator Id's : + * $Id: hc2rIII_3.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: hc2rIII_3.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: hc2rIII_3.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + */ + +#include "hc2rIII.h" + +static void hc2rIII_3(const R *ri, const R *ii, R *O, stride ris, stride iis, stride os, int v, int ivs, int ovs) +{ + DK(KP2_000000000, +2.000000000000000000000000000000000000000000000); + DK(KP1_732050807, +1.732050807568877293527446341505872366942805254); + int i; + for (i = v; i > 0; i = i - 1, ri = ri + ivs, ii = ii + ivs, O = O + ovs) { + E T5, T1, T2, T3, T4; + T4 = ii[0]; + T5 = KP1_732050807 * T4; + T1 = ri[WS(ris, 1)]; + T2 = ri[0]; + T3 = T2 - T1; + O[0] = FMA(KP2_000000000, T2, T1); + O[WS(os, 2)] = -(T3 + T5); + O[WS(os, 1)] = T3 - T5; + } +} + +static const khc2r_desc desc = { 3, "hc2rIII_3", {3, 1, 1, 0}, &GENUS, 0, 0, 0, 0, 0 }; + +void X(codelet_hc2rIII_3) (planner *p) { + X(khc2rIII_register) (p, hc2rIII_3, &desc); +} diff --git a/src/fftw3/rdft/codelets/hc2r/hc2rIII_32.c b/src/fftw3/rdft/codelets/hc2r/hc2rIII_32.c new file mode 100644 index 0000000..ab9409b --- /dev/null +++ b/src/fftw3/rdft/codelets/hc2r/hc2rIII_32.c @@ -0,0 +1,371 @@ +/* + * Copyright (c) 2003 Matteo Frigo + * Copyright (c) 2003 Massachusetts Institute of Technology + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +/* This file was automatically generated --- DO NOT EDIT */ +/* Generated on Sat Jul 5 22:12:16 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_hc2r -compact -variables 4 -sign 1 -n 32 -name hc2rIII_32 -dft-III -include hc2rIII.h */ + +/* + * This function contains 174 FP additions, 84 FP multiplications, + * (or, 138 additions, 48 multiplications, 36 fused multiply/add), + * 66 stack variables, and 64 memory accesses + */ +/* + * Generator Id's : + * $Id: hc2rIII_32.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: hc2rIII_32.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: hc2rIII_32.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + */ + +#include "hc2rIII.h" + +static void hc2rIII_32(const R *ri, const R *ii, R *O, stride ris, stride iis, stride os, int v, int ivs, int ovs) +{ + DK(KP1_913880671, +1.913880671464417729871595773960539938965698411); + DK(KP580569354, +0.580569354508924735272384751634790549382952557); + DK(KP942793473, +0.942793473651995297112775251810508755314920638); + DK(KP1_763842528, +1.763842528696710059425513727320776699016885241); + DK(KP1_546020906, +1.546020906725473921621813219516939601942082586); + DK(KP1_268786568, +1.268786568327290996430343226450986741351374190); + DK(KP196034280, +0.196034280659121203988391127777283691722273346); + DK(KP1_990369453, +1.990369453344393772489673906218959843150949737); + DK(KP765366864, +0.765366864730179543456919968060797733522689125); + DK(KP1_847759065, +1.847759065022573512256366378793576573644833252); + DK(KP1_961570560, +1.961570560806460898252364472268478073947867462); + DK(KP390180644, +0.390180644032256535696569736954044481855383236); + DK(KP1_111140466, +1.111140466039204449485661627897065748749874382); + DK(KP1_662939224, +1.662939224605090474157576755235811513477121624); + DK(KP1_414213562, +1.414213562373095048801688724209698078569671875); + DK(KP2_000000000, +2.000000000000000000000000000000000000000000000); + DK(KP382683432, +0.382683432365089771728459984030398866761344562); + DK(KP923879532, +0.923879532511286756128183189396788286822416626); + DK(KP707106781, +0.707106781186547524400844362104849039284835938); + int i; + for (i = v; i > 0; i = i - 1, ri = ri + ivs, ii = ii + ivs, O = O + ovs) { + E T7, T2i, T2F, Tz, T1k, T1I, T1Z, T1x, Te, T22, T2E, T2j, T1f, T1y, TK; + E T1J, Tm, T2B, TW, T1a, T1C, T1L, T28, T2l, Tt, T2A, T17, T1b, T1F, T1M; + E T2d, T2m; + { + E T3, Tv, T1j, T2h, T6, T1g, Ty, T2g; + { + E T1, T2, T1h, T1i; + T1 = ri[0]; + T2 = ri[WS(ris, 15)]; + T3 = T1 + T2; + Tv = T1 - T2; + T1h = ii[0]; + T1i = ii[WS(iis, 15)]; + T1j = T1h + T1i; + T2h = T1i - T1h; + } + { + E T4, T5, Tw, Tx; + T4 = ri[WS(ris, 8)]; + T5 = ri[WS(ris, 7)]; + T6 = T4 + T5; + T1g = T4 - T5; + Tw = ii[WS(iis, 8)]; + Tx = ii[WS(iis, 7)]; + Ty = Tw + Tx; + T2g = Tw - Tx; + } + T7 = T3 + T6; + T2i = T2g + T2h; + T2F = T2h - T2g; + Tz = Tv - Ty; + T1k = T1g + T1j; + T1I = T1g - T1j; + T1Z = T3 - T6; + T1x = Tv + Ty; + } + { + E Ta, TA, TD, T21, Td, TF, TI, T20; + { + E T8, T9, TB, TC; + T8 = ri[WS(ris, 4)]; + T9 = ri[WS(ris, 11)]; + Ta = T8 + T9; + TA = T8 - T9; + TB = ii[WS(iis, 4)]; + TC = ii[WS(iis, 11)]; + TD = TB + TC; + T21 = TB - TC; + } + { + E Tb, Tc, TG, TH; + Tb = ri[WS(ris, 3)]; + Tc = ri[WS(ris, 12)]; + Td = Tb + Tc; + TF = Tb - Tc; + TG = ii[WS(iis, 3)]; + TH = ii[WS(iis, 12)]; + TI = TG + TH; + T20 = TH - TG; + } + Te = Ta + Td; + T22 = T20 - T21; + T2E = T21 + T20; + T2j = Ta - Td; + { + E T1d, T1e, TE, TJ; + T1d = TA + TD; + T1e = TF + TI; + T1f = KP707106781 * (T1d - T1e); + T1y = KP707106781 * (T1d + T1e); + TE = TA - TD; + TJ = TF - TI; + TK = KP707106781 * (TE + TJ); + T1J = KP707106781 * (TE - TJ); + } + } + { + E Ti, TM, TU, T25, Tl, TR, TP, T26, TQ, TV; + { + E Tg, Th, TS, TT; + Tg = ri[WS(ris, 2)]; + Th = ri[WS(ris, 13)]; + Ti = Tg + Th; + TM = Tg - Th; + TS = ii[WS(iis, 2)]; + TT = ii[WS(iis, 13)]; + TU = TS + TT; + T25 = TS - TT; + } + { + E Tj, Tk, TN, TO; + Tj = ri[WS(ris, 10)]; + Tk = ri[WS(ris, 5)]; + Tl = Tj + Tk; + TR = Tj - Tk; + TN = ii[WS(iis, 10)]; + TO = ii[WS(iis, 5)]; + TP = TN + TO; + T26 = TN - TO; + } + Tm = Ti + Tl; + T2B = T26 + T25; + TQ = TM - TP; + TV = TR + TU; + TW = FNMS(KP382683432, TV, KP923879532 * TQ); + T1a = FMA(KP382683432, TQ, KP923879532 * TV); + { + E T1A, T1B, T24, T27; + T1A = TM + TP; + T1B = TU - TR; + T1C = FNMS(KP923879532, T1B, KP382683432 * T1A); + T1L = FMA(KP923879532, T1A, KP382683432 * T1B); + T24 = Ti - Tl; + T27 = T25 - T26; + T28 = T24 - T27; + T2l = T24 + T27; + } + } + { + E Tp, TX, T15, T2a, Ts, T12, T10, T2b, T11, T16; + { + E Tn, To, T13, T14; + Tn = ri[WS(ris, 1)]; + To = ri[WS(ris, 14)]; + Tp = Tn + To; + TX = Tn - To; + T13 = ii[WS(iis, 1)]; + T14 = ii[WS(iis, 14)]; + T15 = T13 + T14; + T2a = T14 - T13; + } + { + E Tq, Tr, TY, TZ; + Tq = ri[WS(ris, 6)]; + Tr = ri[WS(ris, 9)]; + Ts = Tq + Tr; + T12 = Tq - Tr; + TY = ii[WS(iis, 6)]; + TZ = ii[WS(iis, 9)]; + T10 = TY + TZ; + T2b = TY - TZ; + } + Tt = Tp + Ts; + T2A = T2b + T2a; + T11 = TX - T10; + T16 = T12 - T15; + T17 = FMA(KP923879532, T11, KP382683432 * T16); + T1b = FNMS(KP382683432, T11, KP923879532 * T16); + { + E T1D, T1E, T29, T2c; + T1D = TX + T10; + T1E = T12 + T15; + T1F = FNMS(KP923879532, T1E, KP382683432 * T1D); + T1M = FMA(KP923879532, T1D, KP382683432 * T1E); + T29 = Tp - Ts; + T2c = T2a - T2b; + T2d = T29 + T2c; + T2m = T2c - T29; + } + } + { + E Tf, Tu, T2L, T2M, T2N, T2O; + Tf = T7 + Te; + Tu = Tm + Tt; + T2L = Tf - Tu; + T2M = T2B + T2A; + T2N = T2F - T2E; + T2O = T2M + T2N; + O[0] = KP2_000000000 * (Tf + Tu); + O[WS(os, 16)] = KP2_000000000 * (T2N - T2M); + O[WS(os, 8)] = KP1_414213562 * (T2L + T2O); + O[WS(os, 24)] = KP1_414213562 * (T2O - T2L); + } + { + E T2t, T2x, T2w, T2y; + { + E T2r, T2s, T2u, T2v; + T2r = T1Z - T22; + T2s = KP707106781 * (T2m - T2l); + T2t = T2r + T2s; + T2x = T2r - T2s; + T2u = T2j + T2i; + T2v = KP707106781 * (T28 - T2d); + T2w = T2u - T2v; + T2y = T2v + T2u; + } + O[WS(os, 6)] = FMA(KP1_662939224, T2t, KP1_111140466 * T2w); + O[WS(os, 30)] = FNMS(KP1_961570560, T2x, KP390180644 * T2y); + O[WS(os, 22)] = FNMS(KP1_111140466, T2t, KP1_662939224 * T2w); + O[WS(os, 14)] = FMA(KP390180644, T2x, KP1_961570560 * T2y); + } + { + E T2D, T2J, T2I, T2K; + { + E T2z, T2C, T2G, T2H; + T2z = T7 - Te; + T2C = T2A - T2B; + T2D = T2z + T2C; + T2J = T2z - T2C; + T2G = T2E + T2F; + T2H = Tm - Tt; + T2I = T2G - T2H; + T2K = T2H + T2G; + } + O[WS(os, 4)] = FMA(KP1_847759065, T2D, KP765366864 * T2I); + O[WS(os, 28)] = FNMS(KP1_847759065, T2J, KP765366864 * T2K); + O[WS(os, 20)] = FNMS(KP765366864, T2D, KP1_847759065 * T2I); + O[WS(os, 12)] = FMA(KP765366864, T2J, KP1_847759065 * T2K); + } + { + E T19, T1n, T1m, T1o; + { + E TL, T18, T1c, T1l; + TL = Tz + TK; + T18 = TW + T17; + T19 = TL + T18; + T1n = TL - T18; + T1c = T1a + T1b; + T1l = T1f + T1k; + T1m = T1c + T1l; + T1o = T1c - T1l; + } + O[WS(os, 1)] = FNMS(KP196034280, T1m, KP1_990369453 * T19); + O[WS(os, 25)] = FNMS(KP1_546020906, T1n, KP1_268786568 * T1o); + O[WS(os, 17)] = -(FMA(KP196034280, T19, KP1_990369453 * T1m)); + O[WS(os, 9)] = FMA(KP1_268786568, T1n, KP1_546020906 * T1o); + } + { + E T1r, T1v, T1u, T1w; + { + E T1p, T1q, T1s, T1t; + T1p = Tz - TK; + T1q = T1b - T1a; + T1r = T1p + T1q; + T1v = T1p - T1q; + T1s = T1f - T1k; + T1t = TW - T17; + T1u = T1s - T1t; + T1w = T1t + T1s; + } + O[WS(os, 5)] = FMA(KP1_763842528, T1r, KP942793473 * T1u); + O[WS(os, 29)] = FNMS(KP1_913880671, T1v, KP580569354 * T1w); + O[WS(os, 21)] = FNMS(KP942793473, T1r, KP1_763842528 * T1u); + O[WS(os, 13)] = FMA(KP580569354, T1v, KP1_913880671 * T1w); + } + { + E T1T, T1X, T1W, T1Y; + { + E T1R, T1S, T1U, T1V; + T1R = T1x + T1y; + T1S = T1L + T1M; + T1T = T1R - T1S; + T1X = T1R + T1S; + T1U = T1J + T1I; + T1V = T1C - T1F; + T1W = T1U - T1V; + T1Y = T1V + T1U; + } + O[WS(os, 7)] = FMA(KP1_546020906, T1T, KP1_268786568 * T1W); + O[WS(os, 31)] = FNMS(KP1_990369453, T1X, KP196034280 * T1Y); + O[WS(os, 23)] = FNMS(KP1_268786568, T1T, KP1_546020906 * T1W); + O[WS(os, 15)] = FMA(KP196034280, T1X, KP1_990369453 * T1Y); + } + { + E T2f, T2p, T2o, T2q; + { + E T23, T2e, T2k, T2n; + T23 = T1Z + T22; + T2e = KP707106781 * (T28 + T2d); + T2f = T23 + T2e; + T2p = T23 - T2e; + T2k = T2i - T2j; + T2n = KP707106781 * (T2l + T2m); + T2o = T2k - T2n; + T2q = T2n + T2k; + } + O[WS(os, 2)] = FMA(KP1_961570560, T2f, KP390180644 * T2o); + O[WS(os, 26)] = FNMS(KP1_662939224, T2p, KP1_111140466 * T2q); + O[WS(os, 18)] = FNMS(KP390180644, T2f, KP1_961570560 * T2o); + O[WS(os, 10)] = FMA(KP1_111140466, T2p, KP1_662939224 * T2q); + } + { + E T1H, T1P, T1O, T1Q; + { + E T1z, T1G, T1K, T1N; + T1z = T1x - T1y; + T1G = T1C + T1F; + T1H = T1z + T1G; + T1P = T1z - T1G; + T1K = T1I - T1J; + T1N = T1L - T1M; + T1O = T1K - T1N; + T1Q = T1N + T1K; + } + O[WS(os, 3)] = FMA(KP1_913880671, T1H, KP580569354 * T1O); + O[WS(os, 27)] = FNMS(KP1_763842528, T1P, KP942793473 * T1Q); + O[WS(os, 19)] = FNMS(KP580569354, T1H, KP1_913880671 * T1O); + O[WS(os, 11)] = FMA(KP942793473, T1P, KP1_763842528 * T1Q); + } + } +} + +static const khc2r_desc desc = { 32, "hc2rIII_32", {138, 48, 36, 0}, &GENUS, 0, 0, 0, 0, 0 }; + +void X(codelet_hc2rIII_32) (planner *p) { + X(khc2rIII_register) (p, hc2rIII_32, &desc); +} diff --git a/src/fftw3/rdft/codelets/hc2r/hc2rIII_4.c b/src/fftw3/rdft/codelets/hc2r/hc2rIII_4.c new file mode 100644 index 0000000..d562add --- /dev/null +++ b/src/fftw3/rdft/codelets/hc2r/hc2rIII_4.c @@ -0,0 +1,66 @@ +/* + * Copyright (c) 2003 Matteo Frigo + * Copyright (c) 2003 Massachusetts Institute of Technology + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +/* This file was automatically generated --- DO NOT EDIT */ +/* Generated on Sat Jul 5 22:11:54 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_hc2r -compact -variables 4 -sign 1 -n 4 -name hc2rIII_4 -dft-III -include hc2rIII.h */ + +/* + * This function contains 6 FP additions, 4 FP multiplications, + * (or, 6 additions, 4 multiplications, 0 fused multiply/add), + * 9 stack variables, and 8 memory accesses + */ +/* + * Generator Id's : + * $Id: hc2rIII_4.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: hc2rIII_4.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: hc2rIII_4.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + */ + +#include "hc2rIII.h" + +static void hc2rIII_4(const R *ri, const R *ii, R *O, stride ris, stride iis, stride os, int v, int ivs, int ovs) +{ + DK(KP1_414213562, +1.414213562373095048801688724209698078569671875); + DK(KP2_000000000, +2.000000000000000000000000000000000000000000000); + int i; + for (i = v; i > 0; i = i - 1, ri = ri + ivs, ii = ii + ivs, O = O + ovs) { + E T1, T2, T3, T4, T5, T6; + T1 = ri[0]; + T2 = ri[WS(ris, 1)]; + T3 = T1 - T2; + T4 = ii[0]; + T5 = ii[WS(iis, 1)]; + T6 = T4 + T5; + O[0] = KP2_000000000 * (T1 + T2); + O[WS(os, 2)] = KP2_000000000 * (T5 - T4); + O[WS(os, 1)] = KP1_414213562 * (T3 - T6); + O[WS(os, 3)] = -(KP1_414213562 * (T3 + T6)); + } +} + +static const khc2r_desc desc = { 4, "hc2rIII_4", {6, 4, 0, 0}, &GENUS, 0, 0, 0, 0, 0 }; + +void X(codelet_hc2rIII_4) (planner *p) { + X(khc2rIII_register) (p, hc2rIII_4, &desc); +} diff --git a/src/fftw3/rdft/codelets/hc2r/hc2rIII_5.c b/src/fftw3/rdft/codelets/hc2r/hc2rIII_5.c new file mode 100644 index 0000000..4fb772d --- /dev/null +++ b/src/fftw3/rdft/codelets/hc2r/hc2rIII_5.c @@ -0,0 +1,79 @@ +/* + * Copyright (c) 2003 Matteo Frigo + * Copyright (c) 2003 Massachusetts Institute of Technology + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +/* This file was automatically generated --- DO NOT EDIT */ +/* Generated on Sat Jul 5 22:11:55 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_hc2r -compact -variables 4 -sign 1 -n 5 -name hc2rIII_5 -dft-III -include hc2rIII.h */ + +/* + * This function contains 12 FP additions, 7 FP multiplications, + * (or, 8 additions, 3 multiplications, 4 fused multiply/add), + * 18 stack variables, and 10 memory accesses + */ +/* + * Generator Id's : + * $Id: hc2rIII_5.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: hc2rIII_5.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: hc2rIII_5.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + */ + +#include "hc2rIII.h" + +static void hc2rIII_5(const R *ri, const R *ii, R *O, stride ris, stride iis, stride os, int v, int ivs, int ovs) +{ + DK(KP2_000000000, +2.000000000000000000000000000000000000000000000); + DK(KP1_118033988, +1.118033988749894848204586834365638117720309180); + DK(KP500000000, +0.500000000000000000000000000000000000000000000); + DK(KP1_175570504, +1.175570504584946258337411909278145537195304875); + DK(KP1_902113032, +1.902113032590307144232878666758764286811397268); + int i; + for (i = v; i > 0; i = i - 1, ri = ri + ivs, ii = ii + ivs, O = O + ovs) { + E Ta, Tc, T1, T4, T5, T6, Tb, T7; + { + E T8, T9, T2, T3; + T8 = ii[WS(iis, 1)]; + T9 = ii[0]; + Ta = FMA(KP1_902113032, T8, KP1_175570504 * T9); + Tc = FNMS(KP1_902113032, T9, KP1_175570504 * T8); + T1 = ri[WS(ris, 2)]; + T2 = ri[WS(ris, 1)]; + T3 = ri[0]; + T4 = T2 + T3; + T5 = FMS(KP500000000, T4, T1); + T6 = KP1_118033988 * (T3 - T2); + } + O[0] = FMA(KP2_000000000, T4, T1); + Tb = T6 - T5; + O[WS(os, 2)] = Tb + Tc; + O[WS(os, 3)] = Tc - Tb; + T7 = T5 + T6; + O[WS(os, 1)] = T7 - Ta; + O[WS(os, 4)] = -(T7 + Ta); + } +} + +static const khc2r_desc desc = { 5, "hc2rIII_5", {8, 3, 4, 0}, &GENUS, 0, 0, 0, 0, 0 }; + +void X(codelet_hc2rIII_5) (planner *p) { + X(khc2rIII_register) (p, hc2rIII_5, &desc); +} diff --git a/src/fftw3/rdft/codelets/hc2r/hc2rIII_6.c b/src/fftw3/rdft/codelets/hc2r/hc2rIII_6.c new file mode 100644 index 0000000..506bffd --- /dev/null +++ b/src/fftw3/rdft/codelets/hc2r/hc2rIII_6.c @@ -0,0 +1,77 @@ +/* + * Copyright (c) 2003 Matteo Frigo + * Copyright (c) 2003 Massachusetts Institute of Technology + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +/* This file was automatically generated --- DO NOT EDIT */ +/* Generated on Sat Jul 5 22:11:58 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_hc2r -compact -variables 4 -sign 1 -n 6 -name hc2rIII_6 -dft-III -include hc2rIII.h */ + +/* + * This function contains 12 FP additions, 6 FP multiplications, + * (or, 10 additions, 4 multiplications, 2 fused multiply/add), + * 15 stack variables, and 12 memory accesses + */ +/* + * Generator Id's : + * $Id: hc2rIII_6.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: hc2rIII_6.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: hc2rIII_6.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + */ + +#include "hc2rIII.h" + +static void hc2rIII_6(const R *ri, const R *ii, R *O, stride ris, stride iis, stride os, int v, int ivs, int ovs) +{ + DK(KP2_000000000, +2.000000000000000000000000000000000000000000000); + DK(KP1_732050807, +1.732050807568877293527446341505872366942805254); + int i; + for (i = v; i > 0; i = i - 1, ri = ri + ivs, ii = ii + ivs, O = O + ovs) { + E T1, T6, T4, T5, T9, Tb, Ta, Tc; + T1 = ri[WS(ris, 1)]; + T6 = ii[WS(iis, 1)]; + { + E T2, T3, T7, T8; + T2 = ri[WS(ris, 2)]; + T3 = ri[0]; + T4 = T2 + T3; + T5 = KP1_732050807 * (T2 - T3); + T7 = ii[WS(iis, 2)]; + T8 = ii[0]; + T9 = T7 + T8; + Tb = KP1_732050807 * (T7 - T8); + } + O[0] = KP2_000000000 * (T1 + T4); + O[WS(os, 3)] = KP2_000000000 * (T6 - T9); + Ta = FMA(KP2_000000000, T6, T9); + O[WS(os, 1)] = -(T5 + Ta); + O[WS(os, 5)] = T5 - Ta; + Tc = FMS(KP2_000000000, T1, T4); + O[WS(os, 2)] = Tb - Tc; + O[WS(os, 4)] = Tc + Tb; + } +} + +static const khc2r_desc desc = { 6, "hc2rIII_6", {10, 4, 2, 0}, &GENUS, 0, 0, 0, 0, 0 }; + +void X(codelet_hc2rIII_6) (planner *p) { + X(khc2rIII_register) (p, hc2rIII_6, &desc); +} diff --git a/src/fftw3/rdft/codelets/hc2r/hc2rIII_7.c b/src/fftw3/rdft/codelets/hc2r/hc2rIII_7.c new file mode 100644 index 0000000..f65cbfd --- /dev/null +++ b/src/fftw3/rdft/codelets/hc2r/hc2rIII_7.c @@ -0,0 +1,81 @@ +/* + * Copyright (c) 2003 Matteo Frigo + * Copyright (c) 2003 Massachusetts Institute of Technology + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +/* This file was automatically generated --- DO NOT EDIT */ +/* Generated on Sat Jul 5 22:12:00 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_hc2r -compact -variables 4 -sign 1 -n 7 -name hc2rIII_7 -dft-III -include hc2rIII.h */ + +/* + * This function contains 24 FP additions, 19 FP multiplications, + * (or, 9 additions, 4 multiplications, 15 fused multiply/add), + * 21 stack variables, and 14 memory accesses + */ +/* + * Generator Id's : + * $Id: hc2rIII_7.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: hc2rIII_7.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: hc2rIII_7.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + */ + +#include "hc2rIII.h" + +static void hc2rIII_7(const R *ri, const R *ii, R *O, stride ris, stride iis, stride os, int v, int ivs, int ovs) +{ + DK(KP2_000000000, +2.000000000000000000000000000000000000000000000); + DK(KP1_246979603, +1.246979603717467061050009768008479621264549462); + DK(KP1_801937735, +1.801937735804838252472204639014890102331838324); + DK(KP445041867, +0.445041867912628808577805128993589518932711138); + DK(KP867767478, +0.867767478235116240951536665696717509219981456); + DK(KP1_949855824, +1.949855824363647214036263365987862434465571601); + DK(KP1_563662964, +1.563662964936059617416889053348115500464669037); + int i; + for (i = v; i > 0; i = i - 1, ri = ri + ivs, ii = ii + ivs, O = O + ovs) { + E T9, Td, Tb, T1, T4, T2, T3, T5, Tc, Ta, T6, T8, T7; + T6 = ii[WS(iis, 2)]; + T8 = ii[0]; + T7 = ii[WS(iis, 1)]; + T9 = FMA(KP1_563662964, T6, KP1_949855824 * T7) + (KP867767478 * T8); + Td = FNMS(KP1_949855824, T8, KP1_563662964 * T7) - (KP867767478 * T6); + Tb = FNMS(KP1_563662964, T8, KP1_949855824 * T6) - (KP867767478 * T7); + T1 = ri[WS(ris, 3)]; + T4 = ri[0]; + T2 = ri[WS(ris, 2)]; + T3 = ri[WS(ris, 1)]; + T5 = FMA(KP445041867, T3, KP1_801937735 * T4) + FNMA(KP1_246979603, T2, T1); + Tc = FMA(KP1_801937735, T2, KP445041867 * T4) + FNMA(KP1_246979603, T3, T1); + Ta = FMA(KP1_246979603, T4, T1) + FNMA(KP1_801937735, T3, KP445041867 * T2); + O[WS(os, 1)] = T5 - T9; + O[WS(os, 6)] = -(T5 + T9); + O[WS(os, 4)] = Td - Tc; + O[WS(os, 3)] = Tc + Td; + O[WS(os, 5)] = Tb - Ta; + O[WS(os, 2)] = Ta + Tb; + O[0] = FMA(KP2_000000000, T2 + T3 + T4, T1); + } +} + +static const khc2r_desc desc = { 7, "hc2rIII_7", {9, 4, 15, 0}, &GENUS, 0, 0, 0, 0, 0 }; + +void X(codelet_hc2rIII_7) (planner *p) { + X(khc2rIII_register) (p, hc2rIII_7, &desc); +} diff --git a/src/fftw3/rdft/codelets/hc2r/hc2rIII_8.c b/src/fftw3/rdft/codelets/hc2r/hc2rIII_8.c new file mode 100644 index 0000000..3a7ffb5 --- /dev/null +++ b/src/fftw3/rdft/codelets/hc2r/hc2rIII_8.c @@ -0,0 +1,97 @@ +/* + * Copyright (c) 2003 Matteo Frigo + * Copyright (c) 2003 Massachusetts Institute of Technology + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +/* This file was automatically generated --- DO NOT EDIT */ +/* Generated on Sat Jul 5 22:12:01 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_hc2r -compact -variables 4 -sign 1 -n 8 -name hc2rIII_8 -dft-III -include hc2rIII.h */ + +/* + * This function contains 22 FP additions, 12 FP multiplications, + * (or, 18 additions, 8 multiplications, 4 fused multiply/add), + * 19 stack variables, and 16 memory accesses + */ +/* + * Generator Id's : + * $Id: hc2rIII_8.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: hc2rIII_8.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: hc2rIII_8.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + */ + +#include "hc2rIII.h" + +static void hc2rIII_8(const R *ri, const R *ii, R *O, stride ris, stride iis, stride os, int v, int ivs, int ovs) +{ + DK(KP1_414213562, +1.414213562373095048801688724209698078569671875); + DK(KP765366864, +0.765366864730179543456919968060797733522689125); + DK(KP1_847759065, +1.847759065022573512256366378793576573644833252); + DK(KP2_000000000, +2.000000000000000000000000000000000000000000000); + int i; + for (i = v; i > 0; i = i - 1, ri = ri + ivs, ii = ii + ivs, O = O + ovs) { + E T3, T7, Tf, Tl, T6, Tc, Ta, Tk, Tb, Tg; + { + E T1, T2, Td, Te; + T1 = ri[0]; + T2 = ri[WS(ris, 3)]; + T3 = T1 + T2; + T7 = T1 - T2; + Td = ii[0]; + Te = ii[WS(iis, 3)]; + Tf = Td + Te; + Tl = Te - Td; + } + { + E T4, T5, T8, T9; + T4 = ri[WS(ris, 2)]; + T5 = ri[WS(ris, 1)]; + T6 = T4 + T5; + Tc = T4 - T5; + T8 = ii[WS(iis, 2)]; + T9 = ii[WS(iis, 1)]; + Ta = T8 + T9; + Tk = T8 - T9; + } + O[0] = KP2_000000000 * (T3 + T6); + O[WS(os, 4)] = KP2_000000000 * (Tl - Tk); + Tb = T7 - Ta; + Tg = Tc + Tf; + O[WS(os, 1)] = FNMS(KP765366864, Tg, KP1_847759065 * Tb); + O[WS(os, 5)] = -(FMA(KP765366864, Tb, KP1_847759065 * Tg)); + { + E Th, Ti, Tj, Tm; + Th = T7 + Ta; + Ti = Tc - Tf; + O[WS(os, 3)] = FMA(KP765366864, Th, KP1_847759065 * Ti); + O[WS(os, 7)] = FNMS(KP1_847759065, Th, KP765366864 * Ti); + Tj = T3 - T6; + Tm = Tk + Tl; + O[WS(os, 2)] = KP1_414213562 * (Tj + Tm); + O[WS(os, 6)] = KP1_414213562 * (Tm - Tj); + } + } +} + +static const khc2r_desc desc = { 8, "hc2rIII_8", {18, 8, 4, 0}, &GENUS, 0, 0, 0, 0, 0 }; + +void X(codelet_hc2rIII_8) (planner *p) { + X(khc2rIII_register) (p, hc2rIII_8, &desc); +} diff --git a/src/fftw3/rdft/codelets/hc2r/hc2rIII_9.c b/src/fftw3/rdft/codelets/hc2r/hc2rIII_9.c new file mode 100644 index 0000000..0bcc0ea --- /dev/null +++ b/src/fftw3/rdft/codelets/hc2r/hc2rIII_9.c @@ -0,0 +1,120 @@ +/* + * Copyright (c) 2003 Matteo Frigo + * Copyright (c) 2003 Massachusetts Institute of Technology + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +/* This file was automatically generated --- DO NOT EDIT */ +/* Generated on Sat Jul 5 22:12:05 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_hc2r -compact -variables 4 -sign 1 -n 9 -name hc2rIII_9 -dft-III -include hc2rIII.h */ + +/* + * This function contains 32 FP additions, 18 FP multiplications, + * (or, 22 additions, 8 multiplications, 10 fused multiply/add), + * 35 stack variables, and 18 memory accesses + */ +/* + * Generator Id's : + * $Id: hc2rIII_9.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: hc2rIII_9.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: hc2rIII_9.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + */ + +#include "hc2rIII.h" + +static void hc2rIII_9(const R *ri, const R *ii, R *O, stride ris, stride iis, stride os, int v, int ivs, int ovs) +{ + DK(KP642787609, +0.642787609686539326322643409907263432907559884); + DK(KP766044443, +0.766044443118978035202392650555416673935832457); + DK(KP1_326827896, +1.326827896337876792410842639271782594433726619); + DK(KP1_113340798, +1.113340798452838732905825904094046265936583811); + DK(KP984807753, +0.984807753012208059366743024589523013670643252); + DK(KP173648177, +0.173648177666930348851716626769314796000375677); + DK(KP1_705737063, +1.705737063904886419256501927880148143872040591); + DK(KP300767466, +0.300767466360870593278543795225003852144476517); + DK(KP500000000, +0.500000000000000000000000000000000000000000000); + DK(KP866025403, +0.866025403784438646763723170752936183471402627); + DK(KP2_000000000, +2.000000000000000000000000000000000000000000000); + DK(KP1_732050807, +1.732050807568877293527446341505872366942805254); + int i; + for (i = v; i > 0; i = i - 1, ri = ri + ivs, ii = ii + ivs, O = O + ovs) { + E T3, Ts, Ti, Td, Tc, T8, To, Tu, Tl, Tt, T9, Te; + { + E Th, T1, T2, Tf, Tg; + Tg = ii[WS(iis, 1)]; + Th = KP1_732050807 * Tg; + T1 = ri[WS(ris, 4)]; + T2 = ri[WS(ris, 1)]; + Tf = T2 - T1; + T3 = FMA(KP2_000000000, T2, T1); + Ts = Tf - Th; + Ti = Tf + Th; + } + { + E T4, T7, Tm, Tk, Tn, Tj; + T4 = ri[WS(ris, 3)]; + Td = ii[WS(iis, 3)]; + { + E T5, T6, Ta, Tb; + T5 = ri[0]; + T6 = ri[WS(ris, 2)]; + T7 = T5 + T6; + Tm = KP866025403 * (T6 - T5); + Ta = ii[WS(iis, 2)]; + Tb = ii[0]; + Tc = Ta - Tb; + Tk = KP866025403 * (Tb + Ta); + } + T8 = T4 + T7; + Tn = FMA(KP500000000, Tc, Td); + To = Tm - Tn; + Tu = Tm + Tn; + Tj = FMS(KP500000000, T7, T4); + Tl = Tj + Tk; + Tt = Tj - Tk; + } + O[0] = FMA(KP2_000000000, T8, T3); + T9 = T8 - T3; + Te = KP1_732050807 * (Tc - Td); + O[WS(os, 3)] = T9 + Te; + O[WS(os, 6)] = Te - T9; + { + E Tr, Tp, Tq, Tx, Tv, Tw; + Tr = FNMS(KP1_705737063, Tl, KP300767466 * To); + Tp = FMA(KP173648177, Tl, KP984807753 * To); + Tq = Ti - Tp; + O[WS(os, 2)] = -(FMA(KP2_000000000, Tp, Ti)); + O[WS(os, 8)] = Tr - Tq; + O[WS(os, 5)] = Tq + Tr; + Tx = FMA(KP1_113340798, Tt, KP1_326827896 * Tu); + Tv = FNMS(KP642787609, Tu, KP766044443 * Tt); + Tw = Tv - Ts; + O[WS(os, 1)] = FMA(KP2_000000000, Tv, Ts); + O[WS(os, 7)] = Tx - Tw; + O[WS(os, 4)] = Tw + Tx; + } + } +} + +static const khc2r_desc desc = { 9, "hc2rIII_9", {22, 8, 10, 0}, &GENUS, 0, 0, 0, 0, 0 }; + +void X(codelet_hc2rIII_9) (planner *p) { + X(khc2rIII_register) (p, hc2rIII_9, &desc); +} diff --git a/src/fftw3/rdft/codelets/hc2r/hc2r_10.c b/src/fftw3/rdft/codelets/hc2r/hc2r_10.c new file mode 100644 index 0000000..9e6c5bc --- /dev/null +++ b/src/fftw3/rdft/codelets/hc2r/hc2r_10.c @@ -0,0 +1,118 @@ +/* + * Copyright (c) 2003 Matteo Frigo + * Copyright (c) 2003 Massachusetts Institute of Technology + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +/* This file was automatically generated --- DO NOT EDIT */ +/* Generated on Sat Jul 5 22:11:11 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_hc2r -compact -variables 4 -sign 1 -n 10 -name hc2r_10 -include hc2r.h */ + +/* + * This function contains 34 FP additions, 14 FP multiplications, + * (or, 26 additions, 6 multiplications, 8 fused multiply/add), + * 26 stack variables, and 20 memory accesses + */ +/* + * Generator Id's : + * $Id: hc2r_10.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: hc2r_10.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: hc2r_10.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + */ + +#include "hc2r.h" + +static void hc2r_10(const R *ri, const R *ii, R *O, stride ris, stride iis, stride os, int v, int ivs, int ovs) +{ + DK(KP500000000, +0.500000000000000000000000000000000000000000000); + DK(KP1_902113032, +1.902113032590307144232878666758764286811397268); + DK(KP1_175570504, +1.175570504584946258337411909278145537195304875); + DK(KP2_000000000, +2.000000000000000000000000000000000000000000000); + DK(KP1_118033988, +1.118033988749894848204586834365638117720309180); + int i; + for (i = v; i > 0; i = i - 1, ri = ri + ivs, ii = ii + ivs, O = O + ovs) { + E T3, Tb, Tn, Tv, Tk, Tu, Ta, Ts, Te, Tg, Ti, Tj; + { + E T1, T2, Tl, Tm; + T1 = ri[0]; + T2 = ri[WS(ris, 5)]; + T3 = T1 - T2; + Tb = T1 + T2; + Tl = ii[WS(iis, 4)]; + Tm = ii[WS(iis, 1)]; + Tn = Tl - Tm; + Tv = Tl + Tm; + } + Ti = ii[WS(iis, 2)]; + Tj = ii[WS(iis, 3)]; + Tk = Ti - Tj; + Tu = Ti + Tj; + { + E T6, Tc, T9, Td; + { + E T4, T5, T7, T8; + T4 = ri[WS(ris, 2)]; + T5 = ri[WS(ris, 3)]; + T6 = T4 - T5; + Tc = T4 + T5; + T7 = ri[WS(ris, 4)]; + T8 = ri[WS(ris, 1)]; + T9 = T7 - T8; + Td = T7 + T8; + } + Ta = T6 + T9; + Ts = KP1_118033988 * (T6 - T9); + Te = Tc + Td; + Tg = KP1_118033988 * (Tc - Td); + } + O[WS(os, 5)] = FMA(KP2_000000000, Ta, T3); + O[0] = FMA(KP2_000000000, Te, Tb); + { + E To, Tq, Th, Tp, Tf; + To = FNMS(KP1_902113032, Tn, KP1_175570504 * Tk); + Tq = FMA(KP1_902113032, Tk, KP1_175570504 * Tn); + Tf = FNMS(KP500000000, Te, Tb); + Th = Tf - Tg; + Tp = Tg + Tf; + O[WS(os, 2)] = Th - To; + O[WS(os, 4)] = Tp + Tq; + O[WS(os, 8)] = Th + To; + O[WS(os, 6)] = Tp - Tq; + } + { + E Tw, Ty, Tt, Tx, Tr; + Tw = FNMS(KP1_902113032, Tv, KP1_175570504 * Tu); + Ty = FMA(KP1_902113032, Tu, KP1_175570504 * Tv); + Tr = FNMS(KP500000000, Ta, T3); + Tt = Tr - Ts; + Tx = Ts + Tr; + O[WS(os, 7)] = Tt - Tw; + O[WS(os, 9)] = Tx + Ty; + O[WS(os, 3)] = Tt + Tw; + O[WS(os, 1)] = Tx - Ty; + } + } +} + +static const khc2r_desc desc = { 10, "hc2r_10", {26, 6, 8, 0}, &GENUS, 0, 0, 0, 0, 0 }; + +void X(codelet_hc2r_10) (planner *p) { + X(khc2r_register) (p, hc2r_10, &desc); +} diff --git a/src/fftw3/rdft/codelets/hc2r/hc2r_11.c b/src/fftw3/rdft/codelets/hc2r/hc2r_11.c new file mode 100644 index 0000000..2310502 --- /dev/null +++ b/src/fftw3/rdft/codelets/hc2r/hc2r_11.c @@ -0,0 +1,101 @@ +/* + * Copyright (c) 2003 Matteo Frigo + * Copyright (c) 2003 Massachusetts Institute of Technology + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +/* This file was automatically generated --- DO NOT EDIT */ +/* Generated on Sat Jul 5 22:11:11 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_hc2r -compact -variables 4 -sign 1 -n 11 -name hc2r_11 -include hc2r.h */ + +/* + * This function contains 60 FP additions, 51 FP multiplications, + * (or, 19 additions, 10 multiplications, 41 fused multiply/add), + * 33 stack variables, and 22 memory accesses + */ +/* + * Generator Id's : + * $Id: hc2r_11.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: hc2r_11.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: hc2r_11.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + */ + +#include "hc2r.h" + +static void hc2r_11(const R *ri, const R *ii, R *O, stride ris, stride iis, stride os, int v, int ivs, int ovs) +{ + DK(KP2_000000000, +2.000000000000000000000000000000000000000000000); + DK(KP1_918985947, +1.918985947228994779780736114132655398124909697); + DK(KP1_309721467, +1.309721467890570128113850144932587106367582399); + DK(KP284629676, +0.284629676546570280887585337232739337582102722); + DK(KP830830026, +0.830830026003772851058548298459246407048009821); + DK(KP1_682507065, +1.682507065662362337723623297838735435026584997); + DK(KP563465113, +0.563465113682859395422835830693233798071555798); + DK(KP1_511499148, +1.511499148708516567548071687944688840359434890); + DK(KP1_979642883, +1.979642883761865464752184075553437574753038744); + DK(KP1_819263990, +1.819263990709036742823430766158056920120482102); + DK(KP1_081281634, +1.081281634911195164215271908637383390863541216); + int i; + for (i = v; i > 0; i = i - 1, ri = ri + ivs, ii = ii + ivs, O = O + ovs) { + E Td, Tl, Tf, Th, Tj, T1, T2, T6, T5, T4, T3, T7, Tk, Te, Tg; + E Ti; + { + E T8, Tc, T9, Ta, Tb; + T8 = ii[WS(iis, 2)]; + Tc = ii[WS(iis, 1)]; + T9 = ii[WS(iis, 4)]; + Ta = ii[WS(iis, 5)]; + Tb = ii[WS(iis, 3)]; + Td = FMA(KP1_081281634, T8, KP1_819263990 * T9) + FNMA(KP1_979642883, Ta, KP1_511499148 * Tb) - (KP563465113 * Tc); + Tl = FMA(KP1_979642883, T8, KP1_819263990 * Ta) + FNMA(KP563465113, T9, KP1_081281634 * Tb) - (KP1_511499148 * Tc); + Tf = FMA(KP563465113, T8, KP1_819263990 * Tb) + FNMA(KP1_511499148, Ta, KP1_081281634 * T9) - (KP1_979642883 * Tc); + Th = FMA(KP1_081281634, Tc, KP1_819263990 * T8) + FMA(KP1_979642883, Tb, KP1_511499148 * T9) + (KP563465113 * Ta); + Tj = FMA(KP563465113, Tb, KP1_979642883 * T9) + FNMS(KP1_511499148, T8, KP1_081281634 * Ta) - (KP1_819263990 * Tc); + } + T1 = ri[0]; + T2 = ri[WS(ris, 1)]; + T6 = ri[WS(ris, 5)]; + T5 = ri[WS(ris, 4)]; + T4 = ri[WS(ris, 3)]; + T3 = ri[WS(ris, 2)]; + T7 = FMA(KP1_682507065, T3, T1) + FNMS(KP284629676, T6, KP830830026 * T5) + FNMA(KP1_309721467, T4, KP1_918985947 * T2); + Tk = FMA(KP1_682507065, T4, T1) + FNMS(KP1_918985947, T5, KP830830026 * T6) + FNMA(KP284629676, T3, KP1_309721467 * T2); + Te = FMA(KP830830026, T4, T1) + FNMS(KP1_309721467, T6, KP1_682507065 * T5) + FNMA(KP1_918985947, T3, KP284629676 * T2); + Tg = FMA(KP1_682507065, T2, T1) + FNMS(KP1_918985947, T6, KP830830026 * T3) + FNMA(KP1_309721467, T5, KP284629676 * T4); + Ti = FMA(KP830830026, T2, T1) + FNMS(KP284629676, T5, KP1_682507065 * T6) + FNMA(KP1_918985947, T4, KP1_309721467 * T3); + O[WS(os, 6)] = T7 - Td; + O[WS(os, 8)] = Te - Tf; + O[WS(os, 4)] = Tk + Tl; + O[WS(os, 5)] = T7 + Td; + O[WS(os, 7)] = Tk - Tl; + O[WS(os, 2)] = Ti + Tj; + O[WS(os, 3)] = Te + Tf; + O[WS(os, 10)] = Tg + Th; + O[WS(os, 1)] = Tg - Th; + O[WS(os, 9)] = Ti - Tj; + O[0] = FMA(KP2_000000000, T2 + T3 + T4 + T5 + T6, T1); + } +} + +static const khc2r_desc desc = { 11, "hc2r_11", {19, 10, 41, 0}, &GENUS, 0, 0, 0, 0, 0 }; + +void X(codelet_hc2r_11) (planner *p) { + X(khc2r_register) (p, hc2r_11, &desc); +} diff --git a/src/fftw3/rdft/codelets/hc2r/hc2r_12.c b/src/fftw3/rdft/codelets/hc2r/hc2r_12.c new file mode 100644 index 0000000..4fc3710 --- /dev/null +++ b/src/fftw3/rdft/codelets/hc2r/hc2r_12.c @@ -0,0 +1,126 @@ +/* + * Copyright (c) 2003 Matteo Frigo + * Copyright (c) 2003 Massachusetts Institute of Technology + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +/* This file was automatically generated --- DO NOT EDIT */ +/* Generated on Sat Jul 5 22:11:11 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_hc2r -compact -variables 4 -sign 1 -n 12 -name hc2r_12 -include hc2r.h */ + +/* + * This function contains 38 FP additions, 10 FP multiplications, + * (or, 34 additions, 6 multiplications, 4 fused multiply/add), + * 25 stack variables, and 24 memory accesses + */ +/* + * Generator Id's : + * $Id: hc2r_12.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: hc2r_12.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: hc2r_12.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + */ + +#include "hc2r.h" + +static void hc2r_12(const R *ri, const R *ii, R *O, stride ris, stride iis, stride os, int v, int ivs, int ovs) +{ + DK(KP1_732050807, +1.732050807568877293527446341505872366942805254); + DK(KP2_000000000, +2.000000000000000000000000000000000000000000000); + int i; + for (i = v; i > 0; i = i - 1, ri = ri + ivs, ii = ii + ivs, O = O + ovs) { + E T8, Tb, Tm, TA, Tw, Tx, Tp, TB, T3, Tr, Tg, T6, Ts, Tk; + { + E T9, Ta, Tn, To; + T8 = ri[WS(ris, 3)]; + T9 = ri[WS(ris, 5)]; + Ta = ri[WS(ris, 1)]; + Tb = T9 + Ta; + Tm = FMS(KP2_000000000, T8, Tb); + TA = KP1_732050807 * (T9 - Ta); + Tw = ii[WS(iis, 3)]; + Tn = ii[WS(iis, 5)]; + To = ii[WS(iis, 1)]; + Tx = Tn + To; + Tp = KP1_732050807 * (Tn - To); + TB = FMA(KP2_000000000, Tw, Tx); + } + { + E Tf, T1, T2, Td, Te; + Te = ii[WS(iis, 4)]; + Tf = KP1_732050807 * Te; + T1 = ri[0]; + T2 = ri[WS(ris, 4)]; + Td = T1 - T2; + T3 = FMA(KP2_000000000, T2, T1); + Tr = Td - Tf; + Tg = Td + Tf; + } + { + E Tj, T4, T5, Th, Ti; + Ti = ii[WS(iis, 2)]; + Tj = KP1_732050807 * Ti; + T4 = ri[WS(ris, 6)]; + T5 = ri[WS(ris, 2)]; + Th = T4 - T5; + T6 = FMA(KP2_000000000, T5, T4); + Ts = Th + Tj; + Tk = Th - Tj; + } + { + E T7, Tc, Tz, TC; + T7 = T3 + T6; + Tc = KP2_000000000 * (T8 + Tb); + O[WS(os, 6)] = T7 - Tc; + O[0] = T7 + Tc; + { + E Tl, Tq, TD, TE; + Tl = Tg + Tk; + Tq = Tm - Tp; + O[WS(os, 2)] = Tl - Tq; + O[WS(os, 8)] = Tl + Tq; + TD = Tg - Tk; + TE = TB - TA; + O[WS(os, 5)] = TD - TE; + O[WS(os, 11)] = TD + TE; + } + Tz = Tr - Ts; + TC = TA + TB; + O[WS(os, 1)] = Tz - TC; + O[WS(os, 7)] = Tz + TC; + { + E Tv, Ty, Tt, Tu; + Tv = T3 - T6; + Ty = KP2_000000000 * (Tw - Tx); + O[WS(os, 9)] = Tv - Ty; + O[WS(os, 3)] = Tv + Ty; + Tt = Tr + Ts; + Tu = Tm + Tp; + O[WS(os, 10)] = Tt - Tu; + O[WS(os, 4)] = Tt + Tu; + } + } + } +} + +static const khc2r_desc desc = { 12, "hc2r_12", {34, 6, 4, 0}, &GENUS, 0, 0, 0, 0, 0 }; + +void X(codelet_hc2r_12) (planner *p) { + X(khc2r_register) (p, hc2r_12, &desc); +} diff --git a/src/fftw3/rdft/codelets/hc2r/hc2r_13.c b/src/fftw3/rdft/codelets/hc2r/hc2r_13.c new file mode 100644 index 0000000..3e1ccbd --- /dev/null +++ b/src/fftw3/rdft/codelets/hc2r/hc2r_13.c @@ -0,0 +1,196 @@ +/* + * Copyright (c) 2003 Matteo Frigo + * Copyright (c) 2003 Massachusetts Institute of Technology + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +/* This file was automatically generated --- DO NOT EDIT */ +/* Generated on Sat Jul 5 22:11:12 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_hc2r -compact -variables 4 -sign 1 -n 13 -name hc2r_13 -include hc2r.h */ + +/* + * This function contains 76 FP additions, 35 FP multiplications, + * (or, 56 additions, 15 multiplications, 20 fused multiply/add), + * 56 stack variables, and 26 memory accesses + */ +/* + * Generator Id's : + * $Id: hc2r_13.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: hc2r_13.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: hc2r_13.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + */ + +#include "hc2r.h" + +static void hc2r_13(const R *ri, const R *ii, R *O, stride ris, stride iis, stride os, int v, int ivs, int ovs) +{ + DK(KP1_007074065, +1.007074065727533254493747707736933954186697125); + DK(KP227708958, +0.227708958111581597949308691735310621069285120); + DK(KP531932498, +0.531932498429674575175042127684371897596660533); + DK(KP774781170, +0.774781170935234584261351932853525703557550433); + DK(KP265966249, +0.265966249214837287587521063842185948798330267); + DK(KP516520780, +0.516520780623489722840901288569017135705033622); + DK(KP151805972, +0.151805972074387731966205794490207080712856746); + DK(KP503537032, +0.503537032863766627246873853868466977093348562); + DK(KP166666666, +0.166666666666666666666666666666666666666666667); + DK(KP600925212, +0.600925212577331548853203544578415991041882762); + DK(KP500000000, +0.500000000000000000000000000000000000000000000); + DK(KP256247671, +0.256247671582936600958684654061725059144125175); + DK(KP156891391, +0.156891391051584611046832726756003269660212636); + DK(KP348277202, +0.348277202304271810011321589858529485233929352); + DK(KP1_150281458, +1.150281458948006242736771094910906776922003215); + DK(KP300238635, +0.300238635966332641462884626667381504676006424); + DK(KP011599105, +0.011599105605768290721655456654083252189827041); + DK(KP1_732050807, +1.732050807568877293527446341505872366942805254); + DK(KP2_000000000, +2.000000000000000000000000000000000000000000000); + int i; + for (i = v; i > 0; i = i - 1, ri = ri + ivs, ii = ii + ivs, O = O + ovs) { + E TG, TS, TR, T15, TJ, TT, T1, Tm, Tc, Td, Tg, Tj, Tk, Tn, To; + E Tp; + { + E Ts, Tv, Tw, TE, TC, TB, Tz, TD, TA, TF; + { + E Tt, Tu, Tx, Ty; + Ts = ii[WS(iis, 1)]; + Tt = ii[WS(iis, 3)]; + Tu = ii[WS(iis, 4)]; + Tv = Tt - Tu; + Tw = FMS(KP2_000000000, Ts, Tv); + TE = KP1_732050807 * (Tt + Tu); + TC = ii[WS(iis, 5)]; + Tx = ii[WS(iis, 6)]; + Ty = ii[WS(iis, 2)]; + TB = Tx + Ty; + Tz = KP1_732050807 * (Tx - Ty); + TD = FNMS(KP2_000000000, TC, TB); + } + TA = Tw + Tz; + TF = TD - TE; + TG = FMA(KP011599105, TA, KP300238635 * TF); + TS = FNMS(KP011599105, TF, KP300238635 * TA); + { + E TP, TQ, TH, TI; + TP = Ts + Tv; + TQ = TB + TC; + TR = FNMS(KP348277202, TQ, KP1_150281458 * TP); + T15 = FMA(KP348277202, TP, KP1_150281458 * TQ); + TH = Tw - Tz; + TI = TE + TD; + TJ = FMA(KP156891391, TH, KP256247671 * TI); + TT = FNMS(KP256247671, TH, KP156891391 * TI); + } + } + { + E Tb, Ti, Tf, T6, Th, Te; + T1 = ri[0]; + { + E T7, T8, T9, Ta; + T7 = ri[WS(ris, 5)]; + T8 = ri[WS(ris, 2)]; + T9 = ri[WS(ris, 6)]; + Ta = T8 + T9; + Tb = T7 + Ta; + Ti = FNMS(KP500000000, Ta, T7); + Tf = T8 - T9; + } + { + E T2, T3, T4, T5; + T2 = ri[WS(ris, 1)]; + T3 = ri[WS(ris, 3)]; + T4 = ri[WS(ris, 4)]; + T5 = T3 + T4; + T6 = T2 + T5; + Th = FNMS(KP500000000, T5, T2); + Te = T3 - T4; + } + Tm = KP600925212 * (T6 - Tb); + Tc = T6 + Tb; + Td = FNMS(KP166666666, Tc, T1); + Tg = Te + Tf; + Tj = Th + Ti; + Tk = FMA(KP503537032, Tg, KP151805972 * Tj); + Tn = Th - Ti; + To = Te - Tf; + Tp = FNMS(KP265966249, To, KP516520780 * Tn); + } + O[0] = FMA(KP2_000000000, Tc, T1); + { + E TK, T1b, TV, T12, T16, T18, TO, T1a, Tr, T17, T11, T13; + { + E TU, T14, TM, TN; + TK = KP1_732050807 * (TG + TJ); + T1b = KP1_732050807 * (TS - TT); + TU = TS + TT; + TV = TR - TU; + T12 = FMA(KP2_000000000, TU, TR); + T14 = TG - TJ; + T16 = FMS(KP2_000000000, T14, T15); + T18 = T14 + T15; + TM = FMA(KP774781170, To, KP531932498 * Tn); + TN = FNMS(KP1_007074065, Tj, KP227708958 * Tg); + TO = TM - TN; + T1a = TM + TN; + { + E Tl, Tq, TZ, T10; + Tl = Td - Tk; + Tq = Tm - Tp; + Tr = Tl - Tq; + T17 = Tq + Tl; + TZ = FMA(KP2_000000000, Tk, Td); + T10 = FMA(KP2_000000000, Tp, Tm); + T11 = TZ - T10; + T13 = T10 + TZ; + } + } + O[WS(os, 5)] = T11 - T12; + O[WS(os, 12)] = T13 - T16; + O[WS(os, 1)] = T13 + T16; + O[WS(os, 8)] = T11 + T12; + { + E TL, TW, T19, T1c; + TL = Tr - TK; + TW = TO - TV; + O[WS(os, 7)] = TL - TW; + O[WS(os, 2)] = TL + TW; + T19 = T17 - T18; + T1c = T1a + T1b; + O[WS(os, 3)] = T19 - T1c; + O[WS(os, 9)] = T1c + T19; + } + { + E T1d, T1e, TX, TY; + T1d = T1a - T1b; + T1e = T17 + T18; + O[WS(os, 4)] = T1d + T1e; + O[WS(os, 10)] = T1e - T1d; + TX = Tr + TK; + TY = TO + TV; + O[WS(os, 6)] = TX - TY; + O[WS(os, 11)] = TX + TY; + } + } + } +} + +static const khc2r_desc desc = { 13, "hc2r_13", {56, 15, 20, 0}, &GENUS, 0, 0, 0, 0, 0 }; + +void X(codelet_hc2r_13) (planner *p) { + X(khc2r_register) (p, hc2r_13, &desc); +} diff --git a/src/fftw3/rdft/codelets/hc2r/hc2r_14.c b/src/fftw3/rdft/codelets/hc2r/hc2r_14.c new file mode 100644 index 0000000..dbbb22e --- /dev/null +++ b/src/fftw3/rdft/codelets/hc2r/hc2r_14.c @@ -0,0 +1,134 @@ +/* + * Copyright (c) 2003 Matteo Frigo + * Copyright (c) 2003 Massachusetts Institute of Technology + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +/* This file was automatically generated --- DO NOT EDIT */ +/* Generated on Sat Jul 5 22:11:12 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_hc2r -compact -variables 4 -sign 1 -n 14 -name hc2r_14 -include hc2r.h */ + +/* + * This function contains 62 FP additions, 38 FP multiplications, + * (or, 36 additions, 12 multiplications, 26 fused multiply/add), + * 28 stack variables, and 28 memory accesses + */ +/* + * Generator Id's : + * $Id: hc2r_14.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: hc2r_14.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: hc2r_14.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + */ + +#include "hc2r.h" + +static void hc2r_14(const R *ri, const R *ii, R *O, stride ris, stride iis, stride os, int v, int ivs, int ovs) +{ + DK(KP1_801937735, +1.801937735804838252472204639014890102331838324); + DK(KP445041867, +0.445041867912628808577805128993589518932711138); + DK(KP1_246979603, +1.246979603717467061050009768008479621264549462); + DK(KP867767478, +0.867767478235116240951536665696717509219981456); + DK(KP1_949855824, +1.949855824363647214036263365987862434465571601); + DK(KP1_563662964, +1.563662964936059617416889053348115500464669037); + DK(KP2_000000000, +2.000000000000000000000000000000000000000000000); + int i; + for (i = v; i > 0; i = i - 1, ri = ri + ivs, ii = ii + ivs, O = O + ovs) { + E T3, Td, T6, Te, Tq, Tz, Tn, Ty, Tc, Tg, Tk, Tx, T9, Tf, T1; + E T2; + T1 = ri[0]; + T2 = ri[WS(ris, 7)]; + T3 = T1 - T2; + Td = T1 + T2; + { + E T4, T5, To, Tp; + T4 = ri[WS(ris, 2)]; + T5 = ri[WS(ris, 5)]; + T6 = T4 - T5; + Te = T4 + T5; + To = ii[WS(iis, 2)]; + Tp = ii[WS(iis, 5)]; + Tq = To - Tp; + Tz = To + Tp; + } + { + E Tl, Tm, Ta, Tb; + Tl = ii[WS(iis, 6)]; + Tm = ii[WS(iis, 1)]; + Tn = Tl - Tm; + Ty = Tl + Tm; + Ta = ri[WS(ris, 6)]; + Tb = ri[WS(ris, 1)]; + Tc = Ta - Tb; + Tg = Ta + Tb; + } + { + E Ti, Tj, T7, T8; + Ti = ii[WS(iis, 4)]; + Tj = ii[WS(iis, 3)]; + Tk = Ti - Tj; + Tx = Ti + Tj; + T7 = ri[WS(ris, 4)]; + T8 = ri[WS(ris, 3)]; + T9 = T7 - T8; + Tf = T7 + T8; + } + O[WS(os, 7)] = FMA(KP2_000000000, T6 + T9 + Tc, T3); + O[0] = FMA(KP2_000000000, Te + Tf + Tg, Td); + { + E Tr, Th, TE, TD; + Tr = FNMS(KP1_949855824, Tn, KP1_563662964 * Tk) - (KP867767478 * Tq); + Th = FMA(KP1_246979603, Tf, Td) + FNMA(KP445041867, Tg, KP1_801937735 * Te); + O[WS(os, 4)] = Th - Tr; + O[WS(os, 10)] = Th + Tr; + TE = FMA(KP867767478, Tx, KP1_563662964 * Ty) - (KP1_949855824 * Tz); + TD = FMA(KP1_246979603, Tc, T3) + FNMA(KP1_801937735, T9, KP445041867 * T6); + O[WS(os, 5)] = TD - TE; + O[WS(os, 9)] = TD + TE; + } + { + E Tt, Ts, TA, Tw; + Tt = FMA(KP867767478, Tk, KP1_563662964 * Tn) - (KP1_949855824 * Tq); + Ts = FMA(KP1_246979603, Tg, Td) + FNMA(KP1_801937735, Tf, KP445041867 * Te); + O[WS(os, 12)] = Ts - Tt; + O[WS(os, 2)] = Ts + Tt; + TA = FNMS(KP1_949855824, Ty, KP1_563662964 * Tx) - (KP867767478 * Tz); + Tw = FMA(KP1_246979603, T9, T3) + FNMA(KP445041867, Tc, KP1_801937735 * T6); + O[WS(os, 11)] = Tw - TA; + O[WS(os, 3)] = Tw + TA; + } + { + E TC, TB, Tv, Tu; + TC = FMA(KP1_563662964, Tz, KP1_949855824 * Tx) + (KP867767478 * Ty); + TB = FMA(KP1_246979603, T6, T3) + FNMA(KP1_801937735, Tc, KP445041867 * T9); + O[WS(os, 1)] = TB - TC; + O[WS(os, 13)] = TB + TC; + Tv = FMA(KP1_563662964, Tq, KP1_949855824 * Tk) + (KP867767478 * Tn); + Tu = FMA(KP1_246979603, Te, Td) + FNMA(KP1_801937735, Tg, KP445041867 * Tf); + O[WS(os, 8)] = Tu - Tv; + O[WS(os, 6)] = Tu + Tv; + } + } +} + +static const khc2r_desc desc = { 14, "hc2r_14", {36, 12, 26, 0}, &GENUS, 0, 0, 0, 0, 0 }; + +void X(codelet_hc2r_14) (planner *p) { + X(khc2r_register) (p, hc2r_14, &desc); +} diff --git a/src/fftw3/rdft/codelets/hc2r/hc2r_15.c b/src/fftw3/rdft/codelets/hc2r/hc2r_15.c new file mode 100644 index 0000000..d2eed35 --- /dev/null +++ b/src/fftw3/rdft/codelets/hc2r/hc2r_15.c @@ -0,0 +1,161 @@ +/* + * Copyright (c) 2003 Matteo Frigo + * Copyright (c) 2003 Massachusetts Institute of Technology + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +/* This file was automatically generated --- DO NOT EDIT */ +/* Generated on Sat Jul 5 22:11:12 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_hc2r -compact -variables 4 -sign 1 -n 15 -name hc2r_15 -include hc2r.h */ + +/* + * This function contains 64 FP additions, 31 FP multiplications, + * (or, 47 additions, 14 multiplications, 17 fused multiply/add), + * 44 stack variables, and 30 memory accesses + */ +/* + * Generator Id's : + * $Id: hc2r_15.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: hc2r_15.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: hc2r_15.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + */ + +#include "hc2r.h" + +static void hc2r_15(const R *ri, const R *ii, R *O, stride ris, stride iis, stride os, int v, int ivs, int ovs) +{ + DK(KP1_118033988, +1.118033988749894848204586834365638117720309180); + DK(KP1_902113032, +1.902113032590307144232878666758764286811397268); + DK(KP1_175570504, +1.175570504584946258337411909278145537195304875); + DK(KP500000000, +0.500000000000000000000000000000000000000000000); + DK(KP866025403, +0.866025403784438646763723170752936183471402627); + DK(KP2_000000000, +2.000000000000000000000000000000000000000000000); + DK(KP1_732050807, +1.732050807568877293527446341505872366942805254); + int i; + for (i = v; i > 0; i = i - 1, ri = ri + ivs, ii = ii + ivs, O = O + ovs) { + E T3, Tu, Ti, TB, TZ, T10, TE, TG, TJ, Tn, Tv, Ts, Tw, T8, Td; + E Te; + { + E Th, T1, T2, Tf, Tg; + Tg = ii[WS(iis, 5)]; + Th = KP1_732050807 * Tg; + T1 = ri[0]; + T2 = ri[WS(ris, 5)]; + Tf = T1 - T2; + T3 = FMA(KP2_000000000, T2, T1); + Tu = Tf - Th; + Ti = Tf + Th; + } + { + E T4, TD, T9, TI, T5, T6, T7, Ta, Tb, Tc, Tr, TH, Tm, TC, Tj; + E To; + T4 = ri[WS(ris, 3)]; + TD = ii[WS(iis, 3)]; + T9 = ri[WS(ris, 6)]; + TI = ii[WS(iis, 6)]; + T5 = ri[WS(ris, 7)]; + T6 = ri[WS(ris, 2)]; + T7 = T5 + T6; + Ta = ri[WS(ris, 4)]; + Tb = ri[WS(ris, 1)]; + Tc = Ta + Tb; + { + E Tp, Tq, Tk, Tl; + Tp = ii[WS(iis, 4)]; + Tq = ii[WS(iis, 1)]; + Tr = KP866025403 * (Tp + Tq); + TH = Tp - Tq; + Tk = ii[WS(iis, 7)]; + Tl = ii[WS(iis, 2)]; + Tm = KP866025403 * (Tk - Tl); + TC = Tk + Tl; + } + TB = KP866025403 * (T5 - T6); + TZ = TD - TC; + T10 = TI - TH; + TE = FMA(KP500000000, TC, TD); + TG = KP866025403 * (Ta - Tb); + TJ = FMA(KP500000000, TH, TI); + Tj = FNMS(KP500000000, T7, T4); + Tn = Tj - Tm; + Tv = Tj + Tm; + To = FNMS(KP500000000, Tc, T9); + Ts = To - Tr; + Tw = To + Tr; + T8 = T4 + T7; + Td = T9 + Tc; + Te = T8 + Td; + } + O[0] = FMA(KP2_000000000, Te, T3); + { + E T11, T13, TY, T12, TW, TX; + T11 = FNMS(KP1_902113032, T10, KP1_175570504 * TZ); + T13 = FMA(KP1_902113032, TZ, KP1_175570504 * T10); + TW = FNMS(KP500000000, Te, T3); + TX = KP1_118033988 * (T8 - Td); + TY = TW - TX; + T12 = TX + TW; + O[WS(os, 12)] = TY - T11; + O[WS(os, 9)] = T12 + T13; + O[WS(os, 3)] = TY + T11; + O[WS(os, 6)] = T12 - T13; + } + { + E TP, Tt, TO, TT, TV, TR, TS, TU, TQ; + TP = KP1_118033988 * (Tn - Ts); + Tt = Tn + Ts; + TO = FNMS(KP500000000, Tt, Ti); + TR = TE - TB; + TS = TJ - TG; + TT = FNMS(KP1_902113032, TS, KP1_175570504 * TR); + TV = FMA(KP1_902113032, TR, KP1_175570504 * TS); + O[WS(os, 5)] = FMA(KP2_000000000, Tt, Ti); + TU = TP + TO; + O[WS(os, 11)] = TU - TV; + O[WS(os, 14)] = TU + TV; + TQ = TO - TP; + O[WS(os, 2)] = TQ - TT; + O[WS(os, 8)] = TQ + TT; + } + { + E Tz, Tx, Ty, TL, TN, TF, TK, TM, TA; + Tz = KP1_118033988 * (Tv - Tw); + Tx = Tv + Tw; + Ty = FNMS(KP500000000, Tx, Tu); + TF = TB + TE; + TK = TG + TJ; + TL = FNMS(KP1_902113032, TK, KP1_175570504 * TF); + TN = FMA(KP1_902113032, TF, KP1_175570504 * TK); + O[WS(os, 10)] = FMA(KP2_000000000, Tx, Tu); + TM = Tz + Ty; + O[WS(os, 1)] = TM - TN; + O[WS(os, 4)] = TM + TN; + TA = Ty - Tz; + O[WS(os, 7)] = TA - TL; + O[WS(os, 13)] = TA + TL; + } + } +} + +static const khc2r_desc desc = { 15, "hc2r_15", {47, 14, 17, 0}, &GENUS, 0, 0, 0, 0, 0 }; + +void X(codelet_hc2r_15) (planner *p) { + X(khc2r_register) (p, hc2r_15, &desc); +} diff --git a/src/fftw3/rdft/codelets/hc2r/hc2r_16.c b/src/fftw3/rdft/codelets/hc2r/hc2r_16.c new file mode 100644 index 0000000..60ca018 --- /dev/null +++ b/src/fftw3/rdft/codelets/hc2r/hc2r_16.c @@ -0,0 +1,165 @@ +/* + * Copyright (c) 2003 Matteo Frigo + * Copyright (c) 2003 Massachusetts Institute of Technology + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +/* This file was automatically generated --- DO NOT EDIT */ +/* Generated on Sat Jul 5 22:11:13 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_hc2r -compact -variables 4 -sign 1 -n 16 -name hc2r_16 -include hc2r.h */ + +/* + * This function contains 58 FP additions, 18 FP multiplications, + * (or, 54 additions, 14 multiplications, 4 fused multiply/add), + * 31 stack variables, and 32 memory accesses + */ +/* + * Generator Id's : + * $Id: hc2r_16.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: hc2r_16.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: hc2r_16.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + */ + +#include "hc2r.h" + +static void hc2r_16(const R *ri, const R *ii, R *O, stride ris, stride iis, stride os, int v, int ivs, int ovs) +{ + DK(KP1_847759065, +1.847759065022573512256366378793576573644833252); + DK(KP765366864, +0.765366864730179543456919968060797733522689125); + DK(KP1_414213562, +1.414213562373095048801688724209698078569671875); + DK(KP2_000000000, +2.000000000000000000000000000000000000000000000); + int i; + for (i = v; i > 0; i = i - 1, ri = ri + ivs, ii = ii + ivs, O = O + ovs) { + E T9, TS, Tl, TG, T6, TR, Ti, TD, Td, Tq, Tg, Tt, Tn, Tu, TV; + E TU, TN, TK; + { + E T7, T8, TE, Tj, Tk, TF; + T7 = ri[WS(ris, 2)]; + T8 = ri[WS(ris, 6)]; + TE = T7 - T8; + Tj = ii[WS(iis, 2)]; + Tk = ii[WS(iis, 6)]; + TF = Tj + Tk; + T9 = KP2_000000000 * (T7 + T8); + TS = KP1_414213562 * (TE + TF); + Tl = KP2_000000000 * (Tj - Tk); + TG = KP1_414213562 * (TE - TF); + } + { + E T5, TC, T3, TA; + { + E T4, TB, T1, T2; + T4 = ri[WS(ris, 4)]; + T5 = KP2_000000000 * T4; + TB = ii[WS(iis, 4)]; + TC = KP2_000000000 * TB; + T1 = ri[0]; + T2 = ri[WS(ris, 8)]; + T3 = T1 + T2; + TA = T1 - T2; + } + T6 = T3 + T5; + TR = TA + TC; + Ti = T3 - T5; + TD = TA - TC; + } + { + E TI, TM, TL, TJ; + { + E Tb, Tc, To, Tp; + Tb = ri[WS(ris, 1)]; + Tc = ri[WS(ris, 7)]; + Td = Tb + Tc; + TI = Tb - Tc; + To = ii[WS(iis, 1)]; + Tp = ii[WS(iis, 7)]; + Tq = To - Tp; + TM = To + Tp; + } + { + E Te, Tf, Tr, Ts; + Te = ri[WS(ris, 5)]; + Tf = ri[WS(ris, 3)]; + Tg = Te + Tf; + TL = Te - Tf; + Tr = ii[WS(iis, 5)]; + Ts = ii[WS(iis, 3)]; + Tt = Tr - Ts; + TJ = Tr + Ts; + } + Tn = Td - Tg; + Tu = Tq - Tt; + TV = TM - TL; + TU = TI + TJ; + TN = TL + TM; + TK = TI - TJ; + } + { + E Ta, Th, TT, TW; + Ta = T6 + T9; + Th = KP2_000000000 * (Td + Tg); + O[WS(os, 8)] = Ta - Th; + O[0] = Ta + Th; + TT = TR - TS; + TW = FNMS(KP1_847759065, TV, KP765366864 * TU); + O[WS(os, 11)] = TT - TW; + O[WS(os, 3)] = TT + TW; + } + { + E TX, TY, Tm, Tv; + TX = TR + TS; + TY = FMA(KP1_847759065, TU, KP765366864 * TV); + O[WS(os, 7)] = TX - TY; + O[WS(os, 15)] = TX + TY; + Tm = Ti - Tl; + Tv = KP1_414213562 * (Tn - Tu); + O[WS(os, 10)] = Tm - Tv; + O[WS(os, 2)] = Tm + Tv; + } + { + E Tw, Tx, TH, TO; + Tw = Ti + Tl; + Tx = KP1_414213562 * (Tn + Tu); + O[WS(os, 6)] = Tw - Tx; + O[WS(os, 14)] = Tw + Tx; + TH = TD + TG; + TO = FNMS(KP765366864, TN, KP1_847759065 * TK); + O[WS(os, 9)] = TH - TO; + O[WS(os, 1)] = TH + TO; + } + { + E TP, TQ, Ty, Tz; + TP = TD - TG; + TQ = FMA(KP765366864, TK, KP1_847759065 * TN); + O[WS(os, 5)] = TP - TQ; + O[WS(os, 13)] = TP + TQ; + Ty = T6 - T9; + Tz = KP2_000000000 * (Tt + Tq); + O[WS(os, 4)] = Ty - Tz; + O[WS(os, 12)] = Ty + Tz; + } + } +} + +static const khc2r_desc desc = { 16, "hc2r_16", {54, 14, 4, 0}, &GENUS, 0, 0, 0, 0, 0 }; + +void X(codelet_hc2r_16) (planner *p) { + X(khc2r_register) (p, hc2r_16, &desc); +} diff --git a/src/fftw3/rdft/codelets/hc2r/hc2r_3.c b/src/fftw3/rdft/codelets/hc2r/hc2r_3.c new file mode 100644 index 0000000..990d625 --- /dev/null +++ b/src/fftw3/rdft/codelets/hc2r/hc2r_3.c @@ -0,0 +1,64 @@ +/* + * Copyright (c) 2003 Matteo Frigo + * Copyright (c) 2003 Massachusetts Institute of Technology + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +/* This file was automatically generated --- DO NOT EDIT */ +/* Generated on Sat Jul 5 22:11:11 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_hc2r -compact -variables 4 -sign 1 -n 3 -name hc2r_3 -include hc2r.h */ + +/* + * This function contains 4 FP additions, 2 FP multiplications, + * (or, 3 additions, 1 multiplications, 1 fused multiply/add), + * 8 stack variables, and 6 memory accesses + */ +/* + * Generator Id's : + * $Id: hc2r_3.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: hc2r_3.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: hc2r_3.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + */ + +#include "hc2r.h" + +static void hc2r_3(const R *ri, const R *ii, R *O, stride ris, stride iis, stride os, int v, int ivs, int ovs) +{ + DK(KP2_000000000, +2.000000000000000000000000000000000000000000000); + DK(KP1_732050807, +1.732050807568877293527446341505872366942805254); + int i; + for (i = v; i > 0; i = i - 1, ri = ri + ivs, ii = ii + ivs, O = O + ovs) { + E T5, T1, T2, T3, T4; + T4 = ii[WS(iis, 1)]; + T5 = KP1_732050807 * T4; + T1 = ri[0]; + T2 = ri[WS(ris, 1)]; + T3 = T1 - T2; + O[0] = FMA(KP2_000000000, T2, T1); + O[WS(os, 2)] = T3 + T5; + O[WS(os, 1)] = T3 - T5; + } +} + +static const khc2r_desc desc = { 3, "hc2r_3", {3, 1, 1, 0}, &GENUS, 0, 0, 0, 0, 0 }; + +void X(codelet_hc2r_3) (planner *p) { + X(khc2r_register) (p, hc2r_3, &desc); +} diff --git a/src/fftw3/rdft/codelets/hc2r/hc2r_32.c b/src/fftw3/rdft/codelets/hc2r/hc2r_32.c new file mode 100644 index 0000000..6611654 --- /dev/null +++ b/src/fftw3/rdft/codelets/hc2r/hc2r_32.c @@ -0,0 +1,336 @@ +/* + * Copyright (c) 2003 Matteo Frigo + * Copyright (c) 2003 Massachusetts Institute of Technology + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +/* This file was automatically generated --- DO NOT EDIT */ +/* Generated on Sat Jul 5 22:11:14 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_hc2r -compact -variables 4 -sign 1 -n 32 -name hc2r_32 -include hc2r.h */ + +/* + * This function contains 156 FP additions, 50 FP multiplications, + * (or, 140 additions, 34 multiplications, 16 fused multiply/add), + * 54 stack variables, and 64 memory accesses + */ +/* + * Generator Id's : + * $Id: hc2r_32.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: hc2r_32.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: hc2r_32.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + */ + +#include "hc2r.h" + +static void hc2r_32(const R *ri, const R *ii, R *O, stride ris, stride iis, stride os, int v, int ivs, int ovs) +{ + DK(KP1_662939224, +1.662939224605090474157576755235811513477121624); + DK(KP1_111140466, +1.111140466039204449485661627897065748749874382); + DK(KP1_961570560, +1.961570560806460898252364472268478073947867462); + DK(KP390180644, +0.390180644032256535696569736954044481855383236); + DK(KP765366864, +0.765366864730179543456919968060797733522689125); + DK(KP1_847759065, +1.847759065022573512256366378793576573644833252); + DK(KP707106781, +0.707106781186547524400844362104849039284835938); + DK(KP1_414213562, +1.414213562373095048801688724209698078569671875); + DK(KP2_000000000, +2.000000000000000000000000000000000000000000000); + int i; + for (i = v; i > 0; i = i - 1, ri = ri + ivs, ii = ii + ivs, O = O + ovs) { + E T9, T2c, TB, T1y, T6, T2b, Ty, T1v, Th, T2e, T2f, TD, TK, T1C, T1F; + E T1h, Tp, T2i, T2m, TN, T13, T1K, T1Y, T1k, Tw, TU, T1l, TW, T1V, T2j; + E T1R, T2l; + { + E T7, T8, T1w, Tz, TA, T1x; + T7 = ri[WS(ris, 4)]; + T8 = ri[WS(ris, 12)]; + T1w = T7 - T8; + Tz = ii[WS(iis, 4)]; + TA = ii[WS(iis, 12)]; + T1x = Tz + TA; + T9 = KP2_000000000 * (T7 + T8); + T2c = KP1_414213562 * (T1w + T1x); + TB = KP2_000000000 * (Tz - TA); + T1y = KP1_414213562 * (T1w - T1x); + } + { + E T5, T1u, T3, T1s; + { + E T4, T1t, T1, T2; + T4 = ri[WS(ris, 8)]; + T5 = KP2_000000000 * T4; + T1t = ii[WS(iis, 8)]; + T1u = KP2_000000000 * T1t; + T1 = ri[0]; + T2 = ri[WS(ris, 16)]; + T3 = T1 + T2; + T1s = T1 - T2; + } + T6 = T3 + T5; + T2b = T1s + T1u; + Ty = T3 - T5; + T1v = T1s - T1u; + } + { + E Td, T1A, TG, T1E, Tg, T1D, TJ, T1B; + { + E Tb, Tc, TE, TF; + Tb = ri[WS(ris, 2)]; + Tc = ri[WS(ris, 14)]; + Td = Tb + Tc; + T1A = Tb - Tc; + TE = ii[WS(iis, 2)]; + TF = ii[WS(iis, 14)]; + TG = TE - TF; + T1E = TE + TF; + } + { + E Te, Tf, TH, TI; + Te = ri[WS(ris, 10)]; + Tf = ri[WS(ris, 6)]; + Tg = Te + Tf; + T1D = Te - Tf; + TH = ii[WS(iis, 10)]; + TI = ii[WS(iis, 6)]; + TJ = TH - TI; + T1B = TH + TI; + } + Th = KP2_000000000 * (Td + Tg); + T2e = T1A + T1B; + T2f = T1E - T1D; + TD = Td - Tg; + TK = TG - TJ; + T1C = T1A - T1B; + T1F = T1D + T1E; + T1h = KP2_000000000 * (TJ + TG); + } + { + E Tl, T1I, TZ, T1X, To, T1W, T12, T1J; + { + E Tj, Tk, TX, TY; + Tj = ri[WS(ris, 1)]; + Tk = ri[WS(ris, 15)]; + Tl = Tj + Tk; + T1I = Tj - Tk; + TX = ii[WS(iis, 1)]; + TY = ii[WS(iis, 15)]; + TZ = TX - TY; + T1X = TX + TY; + } + { + E Tm, Tn, T10, T11; + Tm = ri[WS(ris, 9)]; + Tn = ri[WS(ris, 7)]; + To = Tm + Tn; + T1W = Tm - Tn; + T10 = ii[WS(iis, 9)]; + T11 = ii[WS(iis, 7)]; + T12 = T10 - T11; + T1J = T10 + T11; + } + Tp = Tl + To; + T2i = T1I + T1J; + T2m = T1X - T1W; + TN = Tl - To; + T13 = TZ - T12; + T1K = T1I - T1J; + T1Y = T1W + T1X; + T1k = T12 + TZ; + } + { + E Ts, T1L, TT, T1M, Tv, T1O, TQ, T1P; + { + E Tq, Tr, TR, TS; + Tq = ri[WS(ris, 5)]; + Tr = ri[WS(ris, 11)]; + Ts = Tq + Tr; + T1L = Tq - Tr; + TR = ii[WS(iis, 5)]; + TS = ii[WS(iis, 11)]; + TT = TR - TS; + T1M = TR + TS; + } + { + E Tt, Tu, TO, TP; + Tt = ri[WS(ris, 3)]; + Tu = ri[WS(ris, 13)]; + Tv = Tt + Tu; + T1O = Tt - Tu; + TO = ii[WS(iis, 13)]; + TP = ii[WS(iis, 3)]; + TQ = TO - TP; + T1P = TP + TO; + } + Tw = Ts + Tv; + TU = TQ - TT; + T1l = TT + TQ; + TW = Ts - Tv; + { + E T1T, T1U, T1N, T1Q; + T1T = T1L + T1M; + T1U = T1O + T1P; + T1V = KP707106781 * (T1T - T1U); + T2j = KP707106781 * (T1T + T1U); + T1N = T1L - T1M; + T1Q = T1O - T1P; + T1R = KP707106781 * (T1N + T1Q); + T2l = KP707106781 * (T1N - T1Q); + } + } + { + E Tx, T1r, Ti, T1q, Ta; + Tx = KP2_000000000 * (Tp + Tw); + T1r = KP2_000000000 * (T1l + T1k); + Ta = T6 + T9; + Ti = Ta + Th; + T1q = Ta - Th; + O[WS(os, 16)] = Ti - Tx; + O[WS(os, 24)] = T1q + T1r; + O[0] = Ti + Tx; + O[WS(os, 8)] = T1q - T1r; + } + { + E T1i, T1o, T1n, T1p, T1g, T1j, T1m; + T1g = T6 - T9; + T1i = T1g - T1h; + T1o = T1g + T1h; + T1j = Tp - Tw; + T1m = T1k - T1l; + T1n = KP1_414213562 * (T1j - T1m); + T1p = KP1_414213562 * (T1j + T1m); + O[WS(os, 20)] = T1i - T1n; + O[WS(os, 28)] = T1o + T1p; + O[WS(os, 4)] = T1i + T1n; + O[WS(os, 12)] = T1o - T1p; + } + { + E TM, T16, T15, T17; + { + E TC, TL, TV, T14; + TC = Ty - TB; + TL = KP1_414213562 * (TD - TK); + TM = TC + TL; + T16 = TC - TL; + TV = TN + TU; + T14 = TW + T13; + T15 = FNMS(KP765366864, T14, KP1_847759065 * TV); + T17 = FMA(KP765366864, TV, KP1_847759065 * T14); + } + O[WS(os, 18)] = TM - T15; + O[WS(os, 26)] = T16 + T17; + O[WS(os, 2)] = TM + T15; + O[WS(os, 10)] = T16 - T17; + } + { + E T2t, T2x, T2w, T2y; + { + E T2r, T2s, T2u, T2v; + T2r = T2b + T2c; + T2s = FMA(KP1_847759065, T2e, KP765366864 * T2f); + T2t = T2r - T2s; + T2x = T2r + T2s; + T2u = T2i + T2j; + T2v = T2m - T2l; + T2w = FNMS(KP1_961570560, T2v, KP390180644 * T2u); + T2y = FMA(KP1_961570560, T2u, KP390180644 * T2v); + } + O[WS(os, 23)] = T2t - T2w; + O[WS(os, 31)] = T2x + T2y; + O[WS(os, 7)] = T2t + T2w; + O[WS(os, 15)] = T2x - T2y; + } + { + E T1a, T1e, T1d, T1f; + { + E T18, T19, T1b, T1c; + T18 = Ty + TB; + T19 = KP1_414213562 * (TD + TK); + T1a = T18 - T19; + T1e = T18 + T19; + T1b = TN - TU; + T1c = T13 - TW; + T1d = FNMS(KP1_847759065, T1c, KP765366864 * T1b); + T1f = FMA(KP1_847759065, T1b, KP765366864 * T1c); + } + O[WS(os, 22)] = T1a - T1d; + O[WS(os, 30)] = T1e + T1f; + O[WS(os, 6)] = T1a + T1d; + O[WS(os, 14)] = T1e - T1f; + } + { + E T25, T29, T28, T2a; + { + E T23, T24, T26, T27; + T23 = T1v - T1y; + T24 = FMA(KP765366864, T1C, KP1_847759065 * T1F); + T25 = T23 - T24; + T29 = T23 + T24; + T26 = T1K - T1R; + T27 = T1Y - T1V; + T28 = FNMS(KP1_662939224, T27, KP1_111140466 * T26); + T2a = FMA(KP1_662939224, T26, KP1_111140466 * T27); + } + O[WS(os, 21)] = T25 - T28; + O[WS(os, 29)] = T29 + T2a; + O[WS(os, 5)] = T25 + T28; + O[WS(os, 13)] = T29 - T2a; + } + { + E T2h, T2p, T2o, T2q; + { + E T2d, T2g, T2k, T2n; + T2d = T2b - T2c; + T2g = FNMS(KP1_847759065, T2f, KP765366864 * T2e); + T2h = T2d + T2g; + T2p = T2d - T2g; + T2k = T2i - T2j; + T2n = T2l + T2m; + T2o = FNMS(KP1_111140466, T2n, KP1_662939224 * T2k); + T2q = FMA(KP1_111140466, T2k, KP1_662939224 * T2n); + } + O[WS(os, 19)] = T2h - T2o; + O[WS(os, 27)] = T2p + T2q; + O[WS(os, 3)] = T2h + T2o; + O[WS(os, 11)] = T2p - T2q; + } + { + E T1H, T21, T20, T22; + { + E T1z, T1G, T1S, T1Z; + T1z = T1v + T1y; + T1G = FNMS(KP765366864, T1F, KP1_847759065 * T1C); + T1H = T1z + T1G; + T21 = T1z - T1G; + T1S = T1K + T1R; + T1Z = T1V + T1Y; + T20 = FNMS(KP390180644, T1Z, KP1_961570560 * T1S); + T22 = FMA(KP390180644, T1S, KP1_961570560 * T1Z); + } + O[WS(os, 17)] = T1H - T20; + O[WS(os, 25)] = T21 + T22; + O[WS(os, 1)] = T1H + T20; + O[WS(os, 9)] = T21 - T22; + } + } +} + +static const khc2r_desc desc = { 32, "hc2r_32", {140, 34, 16, 0}, &GENUS, 0, 0, 0, 0, 0 }; + +void X(codelet_hc2r_32) (planner *p) { + X(khc2r_register) (p, hc2r_32, &desc); +} diff --git a/src/fftw3/rdft/codelets/hc2r/hc2r_4.c b/src/fftw3/rdft/codelets/hc2r/hc2r_4.c new file mode 100644 index 0000000..00db38d --- /dev/null +++ b/src/fftw3/rdft/codelets/hc2r/hc2r_4.c @@ -0,0 +1,70 @@ +/* + * Copyright (c) 2003 Matteo Frigo + * Copyright (c) 2003 Massachusetts Institute of Technology + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +/* This file was automatically generated --- DO NOT EDIT */ +/* Generated on Sat Jul 5 22:11:11 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_hc2r -compact -variables 4 -sign 1 -n 4 -name hc2r_4 -include hc2r.h */ + +/* + * This function contains 6 FP additions, 2 FP multiplications, + * (or, 6 additions, 2 multiplications, 0 fused multiply/add), + * 10 stack variables, and 8 memory accesses + */ +/* + * Generator Id's : + * $Id: hc2r_4.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: hc2r_4.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: hc2r_4.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + */ + +#include "hc2r.h" + +static void hc2r_4(const R *ri, const R *ii, R *O, stride ris, stride iis, stride os, int v, int ivs, int ovs) +{ + DK(KP2_000000000, +2.000000000000000000000000000000000000000000000); + int i; + for (i = v; i > 0; i = i - 1, ri = ri + ivs, ii = ii + ivs, O = O + ovs) { + E T5, T8, T3, T6; + { + E T4, T7, T1, T2; + T4 = ri[WS(ris, 1)]; + T5 = KP2_000000000 * T4; + T7 = ii[WS(iis, 1)]; + T8 = KP2_000000000 * T7; + T1 = ri[0]; + T2 = ri[WS(ris, 2)]; + T3 = T1 + T2; + T6 = T1 - T2; + } + O[WS(os, 2)] = T3 - T5; + O[WS(os, 3)] = T6 + T8; + O[0] = T3 + T5; + O[WS(os, 1)] = T6 - T8; + } +} + +static const khc2r_desc desc = { 4, "hc2r_4", {6, 2, 0, 0}, &GENUS, 0, 0, 0, 0, 0 }; + +void X(codelet_hc2r_4) (planner *p) { + X(khc2r_register) (p, hc2r_4, &desc); +} diff --git a/src/fftw3/rdft/codelets/hc2r/hc2r_5.c b/src/fftw3/rdft/codelets/hc2r/hc2r_5.c new file mode 100644 index 0000000..fd1c09d --- /dev/null +++ b/src/fftw3/rdft/codelets/hc2r/hc2r_5.c @@ -0,0 +1,79 @@ +/* + * Copyright (c) 2003 Matteo Frigo + * Copyright (c) 2003 Massachusetts Institute of Technology + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +/* This file was automatically generated --- DO NOT EDIT */ +/* Generated on Sat Jul 5 22:11:11 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_hc2r -compact -variables 4 -sign 1 -n 5 -name hc2r_5 -include hc2r.h */ + +/* + * This function contains 12 FP additions, 7 FP multiplications, + * (or, 8 additions, 3 multiplications, 4 fused multiply/add), + * 18 stack variables, and 10 memory accesses + */ +/* + * Generator Id's : + * $Id: hc2r_5.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: hc2r_5.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: hc2r_5.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + */ + +#include "hc2r.h" + +static void hc2r_5(const R *ri, const R *ii, R *O, stride ris, stride iis, stride os, int v, int ivs, int ovs) +{ + DK(KP2_000000000, +2.000000000000000000000000000000000000000000000); + DK(KP1_118033988, +1.118033988749894848204586834365638117720309180); + DK(KP500000000, +0.500000000000000000000000000000000000000000000); + DK(KP1_902113032, +1.902113032590307144232878666758764286811397268); + DK(KP1_175570504, +1.175570504584946258337411909278145537195304875); + int i; + for (i = v; i > 0; i = i - 1, ri = ri + ivs, ii = ii + ivs, O = O + ovs) { + E Ta, Tc, T1, T4, T5, T6, Tb, T7; + { + E T8, T9, T2, T3; + T8 = ii[WS(iis, 1)]; + T9 = ii[WS(iis, 2)]; + Ta = FNMS(KP1_902113032, T9, KP1_175570504 * T8); + Tc = FMA(KP1_902113032, T8, KP1_175570504 * T9); + T1 = ri[0]; + T2 = ri[WS(ris, 1)]; + T3 = ri[WS(ris, 2)]; + T4 = T2 + T3; + T5 = FNMS(KP500000000, T4, T1); + T6 = KP1_118033988 * (T2 - T3); + } + O[0] = FMA(KP2_000000000, T4, T1); + Tb = T6 + T5; + O[WS(os, 1)] = Tb - Tc; + O[WS(os, 4)] = Tb + Tc; + T7 = T5 - T6; + O[WS(os, 2)] = T7 - Ta; + O[WS(os, 3)] = T7 + Ta; + } +} + +static const khc2r_desc desc = { 5, "hc2r_5", {8, 3, 4, 0}, &GENUS, 0, 0, 0, 0, 0 }; + +void X(codelet_hc2r_5) (planner *p) { + X(khc2r_register) (p, hc2r_5, &desc); +} diff --git a/src/fftw3/rdft/codelets/hc2r/hc2r_6.c b/src/fftw3/rdft/codelets/hc2r/hc2r_6.c new file mode 100644 index 0000000..08ce9d0 --- /dev/null +++ b/src/fftw3/rdft/codelets/hc2r/hc2r_6.c @@ -0,0 +1,79 @@ +/* + * Copyright (c) 2003 Matteo Frigo + * Copyright (c) 2003 Massachusetts Institute of Technology + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +/* This file was automatically generated --- DO NOT EDIT */ +/* Generated on Sat Jul 5 22:11:11 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_hc2r -compact -variables 4 -sign 1 -n 6 -name hc2r_6 -include hc2r.h */ + +/* + * This function contains 14 FP additions, 4 FP multiplications, + * (or, 12 additions, 2 multiplications, 2 fused multiply/add), + * 17 stack variables, and 12 memory accesses + */ +/* + * Generator Id's : + * $Id: hc2r_6.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: hc2r_6.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: hc2r_6.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + */ + +#include "hc2r.h" + +static void hc2r_6(const R *ri, const R *ii, R *O, stride ris, stride iis, stride os, int v, int ivs, int ovs) +{ + DK(KP2_000000000, +2.000000000000000000000000000000000000000000000); + DK(KP1_732050807, +1.732050807568877293527446341505872366942805254); + int i; + for (i = v; i > 0; i = i - 1, ri = ri + ivs, ii = ii + ivs, O = O + ovs) { + E T3, T7, Tc, Te, T6, T8, T1, T2, T9, Td; + T1 = ri[0]; + T2 = ri[WS(ris, 3)]; + T3 = T1 - T2; + T7 = T1 + T2; + { + E Ta, Tb, T4, T5; + Ta = ii[WS(iis, 2)]; + Tb = ii[WS(iis, 1)]; + Tc = KP1_732050807 * (Ta - Tb); + Te = KP1_732050807 * (Ta + Tb); + T4 = ri[WS(ris, 2)]; + T5 = ri[WS(ris, 1)]; + T6 = T4 - T5; + T8 = T4 + T5; + } + O[WS(os, 3)] = FMA(KP2_000000000, T6, T3); + O[0] = FMA(KP2_000000000, T8, T7); + T9 = T7 - T8; + O[WS(os, 4)] = T9 - Tc; + O[WS(os, 2)] = T9 + Tc; + Td = T3 - T6; + O[WS(os, 1)] = Td - Te; + O[WS(os, 5)] = Td + Te; + } +} + +static const khc2r_desc desc = { 6, "hc2r_6", {12, 2, 2, 0}, &GENUS, 0, 0, 0, 0, 0 }; + +void X(codelet_hc2r_6) (planner *p) { + X(khc2r_register) (p, hc2r_6, &desc); +} diff --git a/src/fftw3/rdft/codelets/hc2r/hc2r_7.c b/src/fftw3/rdft/codelets/hc2r/hc2r_7.c new file mode 100644 index 0000000..6d1f4c1 --- /dev/null +++ b/src/fftw3/rdft/codelets/hc2r/hc2r_7.c @@ -0,0 +1,81 @@ +/* + * Copyright (c) 2003 Matteo Frigo + * Copyright (c) 2003 Massachusetts Institute of Technology + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +/* This file was automatically generated --- DO NOT EDIT */ +/* Generated on Sat Jul 5 22:11:11 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_hc2r -compact -variables 4 -sign 1 -n 7 -name hc2r_7 -include hc2r.h */ + +/* + * This function contains 24 FP additions, 19 FP multiplications, + * (or, 11 additions, 6 multiplications, 13 fused multiply/add), + * 21 stack variables, and 14 memory accesses + */ +/* + * Generator Id's : + * $Id: hc2r_7.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: hc2r_7.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: hc2r_7.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + */ + +#include "hc2r.h" + +static void hc2r_7(const R *ri, const R *ii, R *O, stride ris, stride iis, stride os, int v, int ivs, int ovs) +{ + DK(KP2_000000000, +2.000000000000000000000000000000000000000000000); + DK(KP1_801937735, +1.801937735804838252472204639014890102331838324); + DK(KP445041867, +0.445041867912628808577805128993589518932711138); + DK(KP1_246979603, +1.246979603717467061050009768008479621264549462); + DK(KP867767478, +0.867767478235116240951536665696717509219981456); + DK(KP1_949855824, +1.949855824363647214036263365987862434465571601); + DK(KP1_563662964, +1.563662964936059617416889053348115500464669037); + int i; + for (i = v; i > 0; i = i - 1, ri = ri + ivs, ii = ii + ivs, O = O + ovs) { + E T9, Td, Tb, T1, T4, T2, T3, T5, Tc, Ta, T6, T8, T7; + T6 = ii[WS(iis, 2)]; + T8 = ii[WS(iis, 1)]; + T7 = ii[WS(iis, 3)]; + T9 = FNMS(KP1_949855824, T7, KP1_563662964 * T6) - (KP867767478 * T8); + Td = FMA(KP867767478, T6, KP1_563662964 * T7) - (KP1_949855824 * T8); + Tb = FMA(KP1_563662964, T8, KP1_949855824 * T6) + (KP867767478 * T7); + T1 = ri[0]; + T4 = ri[WS(ris, 3)]; + T2 = ri[WS(ris, 1)]; + T3 = ri[WS(ris, 2)]; + T5 = FMA(KP1_246979603, T3, T1) + FNMA(KP445041867, T4, KP1_801937735 * T2); + Tc = FMA(KP1_246979603, T4, T1) + FNMA(KP1_801937735, T3, KP445041867 * T2); + Ta = FMA(KP1_246979603, T2, T1) + FNMA(KP1_801937735, T4, KP445041867 * T3); + O[WS(os, 4)] = T5 - T9; + O[WS(os, 3)] = T5 + T9; + O[WS(os, 2)] = Tc + Td; + O[WS(os, 5)] = Tc - Td; + O[WS(os, 6)] = Ta + Tb; + O[WS(os, 1)] = Ta - Tb; + O[0] = FMA(KP2_000000000, T2 + T3 + T4, T1); + } +} + +static const khc2r_desc desc = { 7, "hc2r_7", {11, 6, 13, 0}, &GENUS, 0, 0, 0, 0, 0 }; + +void X(codelet_hc2r_7) (planner *p) { + X(khc2r_register) (p, hc2r_7, &desc); +} diff --git a/src/fftw3/rdft/codelets/hc2r/hc2r_8.c b/src/fftw3/rdft/codelets/hc2r/hc2r_8.c new file mode 100644 index 0000000..dd11bd4 --- /dev/null +++ b/src/fftw3/rdft/codelets/hc2r/hc2r_8.c @@ -0,0 +1,95 @@ +/* + * Copyright (c) 2003 Matteo Frigo + * Copyright (c) 2003 Massachusetts Institute of Technology + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +/* This file was automatically generated --- DO NOT EDIT */ +/* Generated on Sat Jul 5 22:11:11 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_hc2r -compact -variables 4 -sign 1 -n 8 -name hc2r_8 -include hc2r.h */ + +/* + * This function contains 20 FP additions, 6 FP multiplications, + * (or, 20 additions, 6 multiplications, 0 fused multiply/add), + * 21 stack variables, and 16 memory accesses + */ +/* + * Generator Id's : + * $Id: hc2r_8.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: hc2r_8.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: hc2r_8.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + */ + +#include "hc2r.h" + +static void hc2r_8(const R *ri, const R *ii, R *O, stride ris, stride iis, stride os, int v, int ivs, int ovs) +{ + DK(KP1_414213562, +1.414213562373095048801688724209698078569671875); + DK(KP2_000000000, +2.000000000000000000000000000000000000000000000); + int i; + for (i = v; i > 0; i = i - 1, ri = ri + ivs, ii = ii + ivs, O = O + ovs) { + E T5, Tg, T3, Te, T9, Ti, Td, Tj, T6, Ta; + { + E T4, Tf, T1, T2; + T4 = ri[WS(ris, 2)]; + T5 = KP2_000000000 * T4; + Tf = ii[WS(iis, 2)]; + Tg = KP2_000000000 * Tf; + T1 = ri[0]; + T2 = ri[WS(ris, 4)]; + T3 = T1 + T2; + Te = T1 - T2; + { + E T7, T8, Tb, Tc; + T7 = ri[WS(ris, 1)]; + T8 = ri[WS(ris, 3)]; + T9 = KP2_000000000 * (T7 + T8); + Ti = T7 - T8; + Tb = ii[WS(iis, 1)]; + Tc = ii[WS(iis, 3)]; + Td = KP2_000000000 * (Tb - Tc); + Tj = Tb + Tc; + } + } + T6 = T3 + T5; + O[WS(os, 4)] = T6 - T9; + O[0] = T6 + T9; + Ta = T3 - T5; + O[WS(os, 2)] = Ta - Td; + O[WS(os, 6)] = Ta + Td; + { + E Th, Tk, Tl, Tm; + Th = Te - Tg; + Tk = KP1_414213562 * (Ti - Tj); + O[WS(os, 5)] = Th - Tk; + O[WS(os, 1)] = Th + Tk; + Tl = Te + Tg; + Tm = KP1_414213562 * (Ti + Tj); + O[WS(os, 3)] = Tl - Tm; + O[WS(os, 7)] = Tl + Tm; + } + } +} + +static const khc2r_desc desc = { 8, "hc2r_8", {20, 6, 0, 0}, &GENUS, 0, 0, 0, 0, 0 }; + +void X(codelet_hc2r_8) (planner *p) { + X(khc2r_register) (p, hc2r_8, &desc); +} diff --git a/src/fftw3/rdft/codelets/hc2r/hc2r_9.c b/src/fftw3/rdft/codelets/hc2r/hc2r_9.c new file mode 100644 index 0000000..91b0f78 --- /dev/null +++ b/src/fftw3/rdft/codelets/hc2r/hc2r_9.c @@ -0,0 +1,120 @@ +/* + * Copyright (c) 2003 Matteo Frigo + * Copyright (c) 2003 Massachusetts Institute of Technology + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +/* This file was automatically generated --- DO NOT EDIT */ +/* Generated on Sat Jul 5 22:11:11 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_hc2r -compact -variables 4 -sign 1 -n 9 -name hc2r_9 -include hc2r.h */ + +/* + * This function contains 32 FP additions, 18 FP multiplications, + * (or, 22 additions, 8 multiplications, 10 fused multiply/add), + * 35 stack variables, and 18 memory accesses + */ +/* + * Generator Id's : + * $Id: hc2r_9.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: hc2r_9.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: hc2r_9.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + */ + +#include "hc2r.h" + +static void hc2r_9(const R *ri, const R *ii, R *O, stride ris, stride iis, stride os, int v, int ivs, int ovs) +{ + DK(KP984807753, +0.984807753012208059366743024589523013670643252); + DK(KP173648177, +0.173648177666930348851716626769314796000375677); + DK(KP300767466, +0.300767466360870593278543795225003852144476517); + DK(KP1_705737063, +1.705737063904886419256501927880148143872040591); + DK(KP642787609, +0.642787609686539326322643409907263432907559884); + DK(KP766044443, +0.766044443118978035202392650555416673935832457); + DK(KP1_326827896, +1.326827896337876792410842639271782594433726619); + DK(KP1_113340798, +1.113340798452838732905825904094046265936583811); + DK(KP500000000, +0.500000000000000000000000000000000000000000000); + DK(KP866025403, +0.866025403784438646763723170752936183471402627); + DK(KP2_000000000, +2.000000000000000000000000000000000000000000000); + DK(KP1_732050807, +1.732050807568877293527446341505872366942805254); + int i; + for (i = v; i > 0; i = i - 1, ri = ri + ivs, ii = ii + ivs, O = O + ovs) { + E T3, Tq, Tc, Tk, Tj, T8, Tm, Ts, Th, Tr, Tw, Tx; + { + E Tb, T1, T2, T9, Ta; + Ta = ii[WS(iis, 3)]; + Tb = KP1_732050807 * Ta; + T1 = ri[0]; + T2 = ri[WS(ris, 3)]; + T9 = T1 - T2; + T3 = FMA(KP2_000000000, T2, T1); + Tq = T9 + Tb; + Tc = T9 - Tb; + } + { + E T4, T7, Ti, Tg, Tl, Td; + T4 = ri[WS(ris, 1)]; + Tk = ii[WS(iis, 1)]; + { + E T5, T6, Te, Tf; + T5 = ri[WS(ris, 4)]; + T6 = ri[WS(ris, 2)]; + T7 = T5 + T6; + Ti = KP866025403 * (T5 - T6); + Te = ii[WS(iis, 4)]; + Tf = ii[WS(iis, 2)]; + Tg = KP866025403 * (Te + Tf); + Tj = Tf - Te; + } + T8 = T4 + T7; + Tl = FMA(KP500000000, Tj, Tk); + Tm = Ti + Tl; + Ts = Tl - Ti; + Td = FNMS(KP500000000, T7, T4); + Th = Td - Tg; + Tr = Td + Tg; + } + O[0] = FMA(KP2_000000000, T8, T3); + Tw = T3 - T8; + Tx = KP1_732050807 * (Tk - Tj); + O[WS(os, 3)] = Tw - Tx; + O[WS(os, 6)] = Tw + Tx; + { + E Tp, Tn, To, Tv, Tt, Tu; + Tp = FMA(KP1_113340798, Th, KP1_326827896 * Tm); + Tn = FNMS(KP642787609, Tm, KP766044443 * Th); + To = Tc - Tn; + O[WS(os, 1)] = FMA(KP2_000000000, Tn, Tc); + O[WS(os, 7)] = To + Tp; + O[WS(os, 4)] = To - Tp; + Tv = FMA(KP1_705737063, Tr, KP300767466 * Ts); + Tt = FNMS(KP984807753, Ts, KP173648177 * Tr); + Tu = Tq - Tt; + O[WS(os, 2)] = FMA(KP2_000000000, Tt, Tq); + O[WS(os, 8)] = Tu + Tv; + O[WS(os, 5)] = Tu - Tv; + } + } +} + +static const khc2r_desc desc = { 9, "hc2r_9", {22, 8, 10, 0}, &GENUS, 0, 0, 0, 0, 0 }; + +void X(codelet_hc2r_9) (planner *p) { + X(khc2r_register) (p, hc2r_9, &desc); +} diff --git a/src/fftw3/rdft/codelets/hc2r/hcodlist.c b/src/fftw3/rdft/codelets/hc2r/hcodlist.c new file mode 100644 index 0000000..d5d2f07 --- /dev/null +++ b/src/fftw3/rdft/codelets/hc2r/hcodlist.c @@ -0,0 +1,102 @@ +#include "ifftw.h" + +extern void X(codelet_hc2r_3)(planner *); +extern void X(codelet_hc2r_4)(planner *); +extern void X(codelet_hc2r_5)(planner *); +extern void X(codelet_hc2r_6)(planner *); +extern void X(codelet_hc2r_7)(planner *); +extern void X(codelet_hc2r_8)(planner *); +extern void X(codelet_hc2r_9)(planner *); +extern void X(codelet_hc2r_10)(planner *); +extern void X(codelet_hc2r_11)(planner *); +extern void X(codelet_hc2r_12)(planner *); +extern void X(codelet_hc2r_13)(planner *); +extern void X(codelet_hc2r_14)(planner *); +extern void X(codelet_hc2r_15)(planner *); +extern void X(codelet_hc2r_16)(planner *); +extern void X(codelet_hc2r_32)(planner *); +extern void X(codelet_mhc2r_32)(planner *); +extern void X(codelet_mhc2r_64)(planner *); +extern void X(codelet_mhc2r_128)(planner *); +extern void X(codelet_hb_2)(planner *); +extern void X(codelet_hb_3)(planner *); +extern void X(codelet_hb_4)(planner *); +extern void X(codelet_hb_5)(planner *); +extern void X(codelet_hb_6)(planner *); +extern void X(codelet_hb_7)(planner *); +extern void X(codelet_hb_8)(planner *); +extern void X(codelet_hb_9)(planner *); +extern void X(codelet_hb_10)(planner *); +extern void X(codelet_hb_12)(planner *); +extern void X(codelet_hb_15)(planner *); +extern void X(codelet_hb_16)(planner *); +extern void X(codelet_hb_32)(planner *); +extern void X(codelet_hb_64)(planner *); +extern void X(codelet_hc2rIII_2)(planner *); +extern void X(codelet_hc2rIII_3)(planner *); +extern void X(codelet_hc2rIII_4)(planner *); +extern void X(codelet_hc2rIII_5)(planner *); +extern void X(codelet_hc2rIII_6)(planner *); +extern void X(codelet_hc2rIII_7)(planner *); +extern void X(codelet_hc2rIII_8)(planner *); +extern void X(codelet_hc2rIII_9)(planner *); +extern void X(codelet_hc2rIII_10)(planner *); +extern void X(codelet_hc2rIII_12)(planner *); +extern void X(codelet_hc2rIII_15)(planner *); +extern void X(codelet_hc2rIII_16)(planner *); +extern void X(codelet_hc2rIII_32)(planner *); +extern void X(codelet_mhc2rIII_32)(planner *); +extern void X(codelet_mhc2rIII_64)(planner *); + + +extern const solvtab X(solvtab_rdft_hc2r); +const solvtab X(solvtab_rdft_hc2r) = { + SOLVTAB(X(codelet_hc2r_3)), + SOLVTAB(X(codelet_hc2r_4)), + SOLVTAB(X(codelet_hc2r_5)), + SOLVTAB(X(codelet_hc2r_6)), + SOLVTAB(X(codelet_hc2r_7)), + SOLVTAB(X(codelet_hc2r_8)), + SOLVTAB(X(codelet_hc2r_9)), + SOLVTAB(X(codelet_hc2r_10)), + SOLVTAB(X(codelet_hc2r_11)), + SOLVTAB(X(codelet_hc2r_12)), + SOLVTAB(X(codelet_hc2r_13)), + SOLVTAB(X(codelet_hc2r_14)), + SOLVTAB(X(codelet_hc2r_15)), + SOLVTAB(X(codelet_hc2r_16)), + SOLVTAB(X(codelet_hc2r_32)), + SOLVTAB(X(codelet_mhc2r_32)), + SOLVTAB(X(codelet_mhc2r_64)), + SOLVTAB(X(codelet_mhc2r_128)), + SOLVTAB(X(codelet_hb_2)), + SOLVTAB(X(codelet_hb_3)), + SOLVTAB(X(codelet_hb_4)), + SOLVTAB(X(codelet_hb_5)), + SOLVTAB(X(codelet_hb_6)), + SOLVTAB(X(codelet_hb_7)), + SOLVTAB(X(codelet_hb_8)), + SOLVTAB(X(codelet_hb_9)), + SOLVTAB(X(codelet_hb_10)), + SOLVTAB(X(codelet_hb_12)), + SOLVTAB(X(codelet_hb_15)), + SOLVTAB(X(codelet_hb_16)), + SOLVTAB(X(codelet_hb_32)), + SOLVTAB(X(codelet_hb_64)), + SOLVTAB(X(codelet_hc2rIII_2)), + SOLVTAB(X(codelet_hc2rIII_3)), + SOLVTAB(X(codelet_hc2rIII_4)), + SOLVTAB(X(codelet_hc2rIII_5)), + SOLVTAB(X(codelet_hc2rIII_6)), + SOLVTAB(X(codelet_hc2rIII_7)), + SOLVTAB(X(codelet_hc2rIII_8)), + SOLVTAB(X(codelet_hc2rIII_9)), + SOLVTAB(X(codelet_hc2rIII_10)), + SOLVTAB(X(codelet_hc2rIII_12)), + SOLVTAB(X(codelet_hc2rIII_15)), + SOLVTAB(X(codelet_hc2rIII_16)), + SOLVTAB(X(codelet_hc2rIII_32)), + SOLVTAB(X(codelet_mhc2rIII_32)), + SOLVTAB(X(codelet_mhc2rIII_64)), + SOLVTAB_END +}; diff --git a/src/fftw3/rdft/codelets/hc2r/mhc2rIII_32.c b/src/fftw3/rdft/codelets/hc2r/mhc2rIII_32.c new file mode 100644 index 0000000..5ae4ebf --- /dev/null +++ b/src/fftw3/rdft/codelets/hc2r/mhc2rIII_32.c @@ -0,0 +1,381 @@ +/* + * Copyright (c) 2003 Matteo Frigo + * Copyright (c) 2003 Massachusetts Institute of Technology + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +/* This file was automatically generated --- DO NOT EDIT */ +/* Generated on Sat Jul 5 22:12:16 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_hc2r_noinline -compact -variables 4 -sign 1 -n 32 -name mhc2rIII_32 -dft-III -include hc2rIII.h */ + +/* + * This function contains 174 FP additions, 84 FP multiplications, + * (or, 138 additions, 48 multiplications, 36 fused multiply/add), + * 65 stack variables, and 64 memory accesses + */ +/* + * Generator Id's : + * $Id: mhc2rIII_32.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: mhc2rIII_32.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: mhc2rIII_32.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + */ + +#include "hc2rIII.h" + +static void mhc2rIII_32_0(const R *ri, const R *ii, R *O, stride ris, stride iis, stride os) +{ + DK(KP1_913880671, +1.913880671464417729871595773960539938965698411); + DK(KP580569354, +0.580569354508924735272384751634790549382952557); + DK(KP942793473, +0.942793473651995297112775251810508755314920638); + DK(KP1_763842528, +1.763842528696710059425513727320776699016885241); + DK(KP1_546020906, +1.546020906725473921621813219516939601942082586); + DK(KP1_268786568, +1.268786568327290996430343226450986741351374190); + DK(KP196034280, +0.196034280659121203988391127777283691722273346); + DK(KP1_990369453, +1.990369453344393772489673906218959843150949737); + DK(KP765366864, +0.765366864730179543456919968060797733522689125); + DK(KP1_847759065, +1.847759065022573512256366378793576573644833252); + DK(KP1_961570560, +1.961570560806460898252364472268478073947867462); + DK(KP390180644, +0.390180644032256535696569736954044481855383236); + DK(KP1_111140466, +1.111140466039204449485661627897065748749874382); + DK(KP1_662939224, +1.662939224605090474157576755235811513477121624); + DK(KP1_414213562, +1.414213562373095048801688724209698078569671875); + DK(KP2_000000000, +2.000000000000000000000000000000000000000000000); + DK(KP382683432, +0.382683432365089771728459984030398866761344562); + DK(KP923879532, +0.923879532511286756128183189396788286822416626); + DK(KP707106781, +0.707106781186547524400844362104849039284835938); + { + E T7, T2i, T2F, Tz, T1k, T1I, T1Z, T1x, Te, T22, T2E, T2j, T1f, T1y, TK; + E T1J, Tm, T2B, TW, T1a, T1C, T1L, T28, T2l, Tt, T2A, T17, T1b, T1F, T1M; + E T2d, T2m; + { + E T3, Tv, T1j, T2h, T6, T1g, Ty, T2g; + { + E T1, T2, T1h, T1i; + T1 = ri[0]; + T2 = ri[WS(ris, 15)]; + T3 = T1 + T2; + Tv = T1 - T2; + T1h = ii[0]; + T1i = ii[WS(iis, 15)]; + T1j = T1h + T1i; + T2h = T1i - T1h; + } + { + E T4, T5, Tw, Tx; + T4 = ri[WS(ris, 8)]; + T5 = ri[WS(ris, 7)]; + T6 = T4 + T5; + T1g = T4 - T5; + Tw = ii[WS(iis, 8)]; + Tx = ii[WS(iis, 7)]; + Ty = Tw + Tx; + T2g = Tw - Tx; + } + T7 = T3 + T6; + T2i = T2g + T2h; + T2F = T2h - T2g; + Tz = Tv - Ty; + T1k = T1g + T1j; + T1I = T1g - T1j; + T1Z = T3 - T6; + T1x = Tv + Ty; + } + { + E Ta, TA, TD, T21, Td, TF, TI, T20; + { + E T8, T9, TB, TC; + T8 = ri[WS(ris, 4)]; + T9 = ri[WS(ris, 11)]; + Ta = T8 + T9; + TA = T8 - T9; + TB = ii[WS(iis, 4)]; + TC = ii[WS(iis, 11)]; + TD = TB + TC; + T21 = TB - TC; + } + { + E Tb, Tc, TG, TH; + Tb = ri[WS(ris, 3)]; + Tc = ri[WS(ris, 12)]; + Td = Tb + Tc; + TF = Tb - Tc; + TG = ii[WS(iis, 3)]; + TH = ii[WS(iis, 12)]; + TI = TG + TH; + T20 = TH - TG; + } + Te = Ta + Td; + T22 = T20 - T21; + T2E = T21 + T20; + T2j = Ta - Td; + { + E T1d, T1e, TE, TJ; + T1d = TA + TD; + T1e = TF + TI; + T1f = KP707106781 * (T1d - T1e); + T1y = KP707106781 * (T1d + T1e); + TE = TA - TD; + TJ = TF - TI; + TK = KP707106781 * (TE + TJ); + T1J = KP707106781 * (TE - TJ); + } + } + { + E Ti, TM, TU, T25, Tl, TR, TP, T26, TQ, TV; + { + E Tg, Th, TS, TT; + Tg = ri[WS(ris, 2)]; + Th = ri[WS(ris, 13)]; + Ti = Tg + Th; + TM = Tg - Th; + TS = ii[WS(iis, 2)]; + TT = ii[WS(iis, 13)]; + TU = TS + TT; + T25 = TS - TT; + } + { + E Tj, Tk, TN, TO; + Tj = ri[WS(ris, 10)]; + Tk = ri[WS(ris, 5)]; + Tl = Tj + Tk; + TR = Tj - Tk; + TN = ii[WS(iis, 10)]; + TO = ii[WS(iis, 5)]; + TP = TN + TO; + T26 = TN - TO; + } + Tm = Ti + Tl; + T2B = T26 + T25; + TQ = TM - TP; + TV = TR + TU; + TW = FNMS(KP382683432, TV, KP923879532 * TQ); + T1a = FMA(KP382683432, TQ, KP923879532 * TV); + { + E T1A, T1B, T24, T27; + T1A = TM + TP; + T1B = TU - TR; + T1C = FNMS(KP923879532, T1B, KP382683432 * T1A); + T1L = FMA(KP923879532, T1A, KP382683432 * T1B); + T24 = Ti - Tl; + T27 = T25 - T26; + T28 = T24 - T27; + T2l = T24 + T27; + } + } + { + E Tp, TX, T15, T2a, Ts, T12, T10, T2b, T11, T16; + { + E Tn, To, T13, T14; + Tn = ri[WS(ris, 1)]; + To = ri[WS(ris, 14)]; + Tp = Tn + To; + TX = Tn - To; + T13 = ii[WS(iis, 1)]; + T14 = ii[WS(iis, 14)]; + T15 = T13 + T14; + T2a = T14 - T13; + } + { + E Tq, Tr, TY, TZ; + Tq = ri[WS(ris, 6)]; + Tr = ri[WS(ris, 9)]; + Ts = Tq + Tr; + T12 = Tq - Tr; + TY = ii[WS(iis, 6)]; + TZ = ii[WS(iis, 9)]; + T10 = TY + TZ; + T2b = TY - TZ; + } + Tt = Tp + Ts; + T2A = T2b + T2a; + T11 = TX - T10; + T16 = T12 - T15; + T17 = FMA(KP923879532, T11, KP382683432 * T16); + T1b = FNMS(KP382683432, T11, KP923879532 * T16); + { + E T1D, T1E, T29, T2c; + T1D = TX + T10; + T1E = T12 + T15; + T1F = FNMS(KP923879532, T1E, KP382683432 * T1D); + T1M = FMA(KP923879532, T1D, KP382683432 * T1E); + T29 = Tp - Ts; + T2c = T2a - T2b; + T2d = T29 + T2c; + T2m = T2c - T29; + } + } + { + E Tf, Tu, T2L, T2M, T2N, T2O; + Tf = T7 + Te; + Tu = Tm + Tt; + T2L = Tf - Tu; + T2M = T2B + T2A; + T2N = T2F - T2E; + T2O = T2M + T2N; + O[0] = KP2_000000000 * (Tf + Tu); + O[WS(os, 16)] = KP2_000000000 * (T2N - T2M); + O[WS(os, 8)] = KP1_414213562 * (T2L + T2O); + O[WS(os, 24)] = KP1_414213562 * (T2O - T2L); + } + { + E T2t, T2x, T2w, T2y; + { + E T2r, T2s, T2u, T2v; + T2r = T1Z - T22; + T2s = KP707106781 * (T2m - T2l); + T2t = T2r + T2s; + T2x = T2r - T2s; + T2u = T2j + T2i; + T2v = KP707106781 * (T28 - T2d); + T2w = T2u - T2v; + T2y = T2v + T2u; + } + O[WS(os, 6)] = FMA(KP1_662939224, T2t, KP1_111140466 * T2w); + O[WS(os, 30)] = FNMS(KP1_961570560, T2x, KP390180644 * T2y); + O[WS(os, 22)] = FNMS(KP1_111140466, T2t, KP1_662939224 * T2w); + O[WS(os, 14)] = FMA(KP390180644, T2x, KP1_961570560 * T2y); + } + { + E T2D, T2J, T2I, T2K; + { + E T2z, T2C, T2G, T2H; + T2z = T7 - Te; + T2C = T2A - T2B; + T2D = T2z + T2C; + T2J = T2z - T2C; + T2G = T2E + T2F; + T2H = Tm - Tt; + T2I = T2G - T2H; + T2K = T2H + T2G; + } + O[WS(os, 4)] = FMA(KP1_847759065, T2D, KP765366864 * T2I); + O[WS(os, 28)] = FNMS(KP1_847759065, T2J, KP765366864 * T2K); + O[WS(os, 20)] = FNMS(KP765366864, T2D, KP1_847759065 * T2I); + O[WS(os, 12)] = FMA(KP765366864, T2J, KP1_847759065 * T2K); + } + { + E T19, T1n, T1m, T1o; + { + E TL, T18, T1c, T1l; + TL = Tz + TK; + T18 = TW + T17; + T19 = TL + T18; + T1n = TL - T18; + T1c = T1a + T1b; + T1l = T1f + T1k; + T1m = T1c + T1l; + T1o = T1c - T1l; + } + O[WS(os, 1)] = FNMS(KP196034280, T1m, KP1_990369453 * T19); + O[WS(os, 25)] = FNMS(KP1_546020906, T1n, KP1_268786568 * T1o); + O[WS(os, 17)] = -(FMA(KP196034280, T19, KP1_990369453 * T1m)); + O[WS(os, 9)] = FMA(KP1_268786568, T1n, KP1_546020906 * T1o); + } + { + E T1r, T1v, T1u, T1w; + { + E T1p, T1q, T1s, T1t; + T1p = Tz - TK; + T1q = T1b - T1a; + T1r = T1p + T1q; + T1v = T1p - T1q; + T1s = T1f - T1k; + T1t = TW - T17; + T1u = T1s - T1t; + T1w = T1t + T1s; + } + O[WS(os, 5)] = FMA(KP1_763842528, T1r, KP942793473 * T1u); + O[WS(os, 29)] = FNMS(KP1_913880671, T1v, KP580569354 * T1w); + O[WS(os, 21)] = FNMS(KP942793473, T1r, KP1_763842528 * T1u); + O[WS(os, 13)] = FMA(KP580569354, T1v, KP1_913880671 * T1w); + } + { + E T1T, T1X, T1W, T1Y; + { + E T1R, T1S, T1U, T1V; + T1R = T1x + T1y; + T1S = T1L + T1M; + T1T = T1R - T1S; + T1X = T1R + T1S; + T1U = T1J + T1I; + T1V = T1C - T1F; + T1W = T1U - T1V; + T1Y = T1V + T1U; + } + O[WS(os, 7)] = FMA(KP1_546020906, T1T, KP1_268786568 * T1W); + O[WS(os, 31)] = FNMS(KP1_990369453, T1X, KP196034280 * T1Y); + O[WS(os, 23)] = FNMS(KP1_268786568, T1T, KP1_546020906 * T1W); + O[WS(os, 15)] = FMA(KP196034280, T1X, KP1_990369453 * T1Y); + } + { + E T2f, T2p, T2o, T2q; + { + E T23, T2e, T2k, T2n; + T23 = T1Z + T22; + T2e = KP707106781 * (T28 + T2d); + T2f = T23 + T2e; + T2p = T23 - T2e; + T2k = T2i - T2j; + T2n = KP707106781 * (T2l + T2m); + T2o = T2k - T2n; + T2q = T2n + T2k; + } + O[WS(os, 2)] = FMA(KP1_961570560, T2f, KP390180644 * T2o); + O[WS(os, 26)] = FNMS(KP1_662939224, T2p, KP1_111140466 * T2q); + O[WS(os, 18)] = FNMS(KP390180644, T2f, KP1_961570560 * T2o); + O[WS(os, 10)] = FMA(KP1_111140466, T2p, KP1_662939224 * T2q); + } + { + E T1H, T1P, T1O, T1Q; + { + E T1z, T1G, T1K, T1N; + T1z = T1x - T1y; + T1G = T1C + T1F; + T1H = T1z + T1G; + T1P = T1z - T1G; + T1K = T1I - T1J; + T1N = T1L - T1M; + T1O = T1K - T1N; + T1Q = T1N + T1K; + } + O[WS(os, 3)] = FMA(KP1_913880671, T1H, KP580569354 * T1O); + O[WS(os, 27)] = FNMS(KP1_763842528, T1P, KP942793473 * T1Q); + O[WS(os, 19)] = FNMS(KP580569354, T1H, KP1_913880671 * T1O); + O[WS(os, 11)] = FMA(KP942793473, T1P, KP1_763842528 * T1Q); + } + } +} + +static void mhc2rIII_32(const R *ri, const R *ii, R *O, stride ris, stride iis, stride os, int v, int ivs, int ovs) +{ + int i; + for (i = v; i > 0; --i) { + mhc2rIII_32_0(ri, ii, O, ris, iis, os); + ri += ivs; + ii += ivs; + O += ovs; + } +} + +static const khc2r_desc desc = { 32, "mhc2rIII_32", {138, 48, 36, 0}, &GENUS, 0, 0, 0, 0, 0 }; + +void X(codelet_mhc2rIII_32) (planner *p) { + X(khc2rIII_register) (p, mhc2rIII_32, &desc); +} diff --git a/src/fftw3/rdft/codelets/hc2r/mhc2rIII_64.c b/src/fftw3/rdft/codelets/hc2r/mhc2rIII_64.c new file mode 100644 index 0000000..42e7790 --- /dev/null +++ b/src/fftw3/rdft/codelets/hc2r/mhc2rIII_64.c @@ -0,0 +1,819 @@ +/* + * Copyright (c) 2003 Matteo Frigo + * Copyright (c) 2003 Massachusetts Institute of Technology + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +/* This file was automatically generated --- DO NOT EDIT */ +/* Generated on Sat Jul 5 22:12:24 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_hc2r_noinline -compact -variables 4 -sign 1 -n 64 -name mhc2rIII_64 -dft-III -include hc2rIII.h */ + +/* + * This function contains 434 FP additions, 208 FP multiplications, + * (or, 342 additions, 116 multiplications, 92 fused multiply/add), + * 129 stack variables, and 128 memory accesses + */ +/* + * Generator Id's : + * $Id: mhc2rIII_64.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: mhc2rIII_64.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: mhc2rIII_64.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + */ + +#include "hc2rIII.h" + +static void mhc2rIII_64_0(const R *ri, const R *ii, R *O, stride ris, stride iis, stride os) +{ + DK(KP1_343117909, +1.343117909694036801250753700854843606457501264); + DK(KP1_481902250, +1.481902250709918182351233794990325459457910619); + DK(KP1_807978586, +1.807978586246886663172400594461074097420264050); + DK(KP855110186, +0.855110186860564188641933713777597068609157259); + DK(KP1_997590912, +1.997590912410344785429543209518201388886407229); + DK(KP098135348, +0.098135348654836028509909953885365316629490726); + DK(KP673779706, +0.673779706784440101378506425238295140955533559); + DK(KP1_883088130, +1.883088130366041556825018805199004714371179592); + DK(KP195090322, +0.195090322016128267848284868477022240927691618); + DK(KP980785280, +0.980785280403230449126182236134239036973933731); + DK(KP1_191398608, +1.191398608984866686934073057659939779023852677); + DK(KP1_606415062, +1.606415062961289819613353025926283847759138854); + DK(KP1_715457220, +1.715457220000544139804539968569540274084981599); + DK(KP1_028205488, +1.028205488386443453187387677937631545216098241); + DK(KP1_978353019, +1.978353019929561946903347476032486127967379067); + DK(KP293460948, +0.293460948910723503317700259293435639412430633); + DK(KP485960359, +0.485960359806527779896548324154942236641981567); + DK(KP1_940062506, +1.940062506389087985207968414572200502913731924); + DK(KP555570233, +0.555570233019602224742830813948532874374937191); + DK(KP831469612, +0.831469612302545237078788377617905756738560812); + DK(KP1_268786568, +1.268786568327290996430343226450986741351374190); + DK(KP1_546020906, +1.546020906725473921621813219516939601942082586); + DK(KP1_763842528, +1.763842528696710059425513727320776699016885241); + DK(KP942793473, +0.942793473651995297112775251810508755314920638); + DK(KP1_990369453, +1.990369453344393772489673906218959843150949737); + DK(KP196034280, +0.196034280659121203988391127777283691722273346); + DK(KP580569354, +0.580569354508924735272384751634790549382952557); + DK(KP1_913880671, +1.913880671464417729871595773960539938965698411); + DK(KP1_662939224, +1.662939224605090474157576755235811513477121624); + DK(KP1_111140466, +1.111140466039204449485661627897065748749874382); + DK(KP390180644, +0.390180644032256535696569736954044481855383236); + DK(KP1_961570560, +1.961570560806460898252364472268478073947867462); + DK(KP765366864, +0.765366864730179543456919968060797733522689125); + DK(KP1_847759065, +1.847759065022573512256366378793576573644833252); + DK(KP1_414213562, +1.414213562373095048801688724209698078569671875); + DK(KP2_000000000, +2.000000000000000000000000000000000000000000000); + DK(KP382683432, +0.382683432365089771728459984030398866761344562); + DK(KP923879532, +0.923879532511286756128183189396788286822416626); + DK(KP707106781, +0.707106781186547524400844362104849039284835938); + { + E T15, T3t, T3U, T2N, Tf, T6b, T6u, T6R, T4L, T5J, T1g, T3V, T5q, T5U, T2I; + E T3u, Tu, T6v, T4V, T5s, T6e, T6Q, T1s, T2D, T1D, T2E, T3B, T3Y, T4Q, T5r; + E T3y, T3X, TK, T6g, T57, T5N, T6j, T6N, T1W, T34, T25, T35, T3J, T4j, T52; + E T5M, T3G, T4i, TZ, T6l, T5i, T5Q, T6o, T6M, T2n, T37, T2w, T38, T3Q, T4m; + E T5d, T5P, T3N, T4l; + { + E T3, T11, T2M, T5n, T6, T2J, T14, T5m, Ta, T16, T19, T4J, Td, T1b, T1e; + E T4I; + { + E T1, T2, T2K, T2L; + T1 = ri[0]; + T2 = ri[WS(ris, 31)]; + T3 = T1 + T2; + T11 = T1 - T2; + T2K = ii[0]; + T2L = ii[WS(iis, 31)]; + T2M = T2K + T2L; + T5n = T2L - T2K; + } + { + E T4, T5, T12, T13; + T4 = ri[WS(ris, 16)]; + T5 = ri[WS(ris, 15)]; + T6 = T4 + T5; + T2J = T4 - T5; + T12 = ii[WS(iis, 16)]; + T13 = ii[WS(iis, 15)]; + T14 = T12 + T13; + T5m = T12 - T13; + } + { + E T8, T9, T17, T18; + T8 = ri[WS(ris, 8)]; + T9 = ri[WS(ris, 23)]; + Ta = T8 + T9; + T16 = T8 - T9; + T17 = ii[WS(iis, 8)]; + T18 = ii[WS(iis, 23)]; + T19 = T17 + T18; + T4J = T17 - T18; + } + { + E Tb, Tc, T1c, T1d; + Tb = ri[WS(ris, 7)]; + Tc = ri[WS(ris, 24)]; + Td = Tb + Tc; + T1b = Tb - Tc; + T1c = ii[WS(iis, 7)]; + T1d = ii[WS(iis, 24)]; + T1e = T1c + T1d; + T4I = T1d - T1c; + } + { + E T7, Te, T1a, T1f; + T15 = T11 - T14; + T3t = T11 + T14; + T3U = T2J - T2M; + T2N = T2J + T2M; + T7 = T3 + T6; + Te = Ta + Td; + Tf = T7 + Te; + T6b = T7 - Te; + { + E T6s, T6t, T4H, T4K; + T6s = T4J + T4I; + T6t = T5n - T5m; + T6u = T6s + T6t; + T6R = T6t - T6s; + T4H = T3 - T6; + T4K = T4I - T4J; + T4L = T4H + T4K; + T5J = T4H - T4K; + } + T1a = T16 - T19; + T1f = T1b - T1e; + T1g = KP707106781 * (T1a + T1f); + T3V = KP707106781 * (T1a - T1f); + { + E T5o, T5p, T2G, T2H; + T5o = T5m + T5n; + T5p = Ta - Td; + T5q = T5o - T5p; + T5U = T5p + T5o; + T2G = T16 + T19; + T2H = T1b + T1e; + T2I = KP707106781 * (T2G - T2H); + T3u = KP707106781 * (T2G + T2H); + } + } + } + { + E Ti, T1i, T1q, T4N, Tl, T1n, T1l, T4O, Tp, T1t, T1B, T4S, Ts, T1y, T1w; + E T4T; + { + E Tg, Th, T1o, T1p; + Tg = ri[WS(ris, 4)]; + Th = ri[WS(ris, 27)]; + Ti = Tg + Th; + T1i = Tg - Th; + T1o = ii[WS(iis, 4)]; + T1p = ii[WS(iis, 27)]; + T1q = T1o + T1p; + T4N = T1o - T1p; + } + { + E Tj, Tk, T1j, T1k; + Tj = ri[WS(ris, 20)]; + Tk = ri[WS(ris, 11)]; + Tl = Tj + Tk; + T1n = Tj - Tk; + T1j = ii[WS(iis, 20)]; + T1k = ii[WS(iis, 11)]; + T1l = T1j + T1k; + T4O = T1j - T1k; + } + { + E Tn, To, T1z, T1A; + Tn = ri[WS(ris, 3)]; + To = ri[WS(ris, 28)]; + Tp = Tn + To; + T1t = Tn - To; + T1z = ii[WS(iis, 3)]; + T1A = ii[WS(iis, 28)]; + T1B = T1z + T1A; + T4S = T1A - T1z; + } + { + E Tq, Tr, T1u, T1v; + Tq = ri[WS(ris, 12)]; + Tr = ri[WS(ris, 19)]; + Ts = Tq + Tr; + T1y = Tq - Tr; + T1u = ii[WS(iis, 12)]; + T1v = ii[WS(iis, 19)]; + T1w = T1u + T1v; + T4T = T1u - T1v; + } + { + E Tm, Tt, T4R, T4U; + Tm = Ti + Tl; + Tt = Tp + Ts; + Tu = Tm + Tt; + T6v = Tm - Tt; + T4R = Tp - Ts; + T4U = T4S - T4T; + T4V = T4R + T4U; + T5s = T4U - T4R; + } + { + E T6c, T6d, T1m, T1r; + T6c = T4T + T4S; + T6d = T4O + T4N; + T6e = T6c - T6d; + T6Q = T6d + T6c; + T1m = T1i - T1l; + T1r = T1n + T1q; + T1s = FNMS(KP382683432, T1r, KP923879532 * T1m); + T2D = FMA(KP382683432, T1m, KP923879532 * T1r); + } + { + E T1x, T1C, T3z, T3A; + T1x = T1t - T1w; + T1C = T1y - T1B; + T1D = FMA(KP923879532, T1x, KP382683432 * T1C); + T2E = FNMS(KP382683432, T1x, KP923879532 * T1C); + T3z = T1t + T1w; + T3A = T1y + T1B; + T3B = FNMS(KP923879532, T3A, KP382683432 * T3z); + T3Y = FMA(KP923879532, T3z, KP382683432 * T3A); + } + { + E T4M, T4P, T3w, T3x; + T4M = Ti - Tl; + T4P = T4N - T4O; + T4Q = T4M - T4P; + T5r = T4M + T4P; + T3w = T1i + T1l; + T3x = T1q - T1n; + T3y = FNMS(KP923879532, T3x, KP382683432 * T3w); + T3X = FMA(KP923879532, T3w, KP382683432 * T3x); + } + } + { + E Ty, T1G, T23, T54, TB, T20, T1J, T55, TI, T4Z, T1U, T1Y, TF, T50, T1P; + E T1X; + { + E Tw, Tx, T1H, T1I; + Tw = ri[WS(ris, 2)]; + Tx = ri[WS(ris, 29)]; + Ty = Tw + Tx; + T1G = Tw - Tx; + { + E T21, T22, Tz, TA; + T21 = ii[WS(iis, 2)]; + T22 = ii[WS(iis, 29)]; + T23 = T21 + T22; + T54 = T21 - T22; + Tz = ri[WS(ris, 18)]; + TA = ri[WS(ris, 13)]; + TB = Tz + TA; + T20 = Tz - TA; + } + T1H = ii[WS(iis, 18)]; + T1I = ii[WS(iis, 13)]; + T1J = T1H + T1I; + T55 = T1H - T1I; + { + E TG, TH, T1Q, T1R, T1S, T1T; + TG = ri[WS(ris, 5)]; + TH = ri[WS(ris, 26)]; + T1Q = TG - TH; + T1R = ii[WS(iis, 5)]; + T1S = ii[WS(iis, 26)]; + T1T = T1R + T1S; + TI = TG + TH; + T4Z = T1S - T1R; + T1U = T1Q - T1T; + T1Y = T1Q + T1T; + } + { + E TD, TE, T1L, T1M, T1N, T1O; + TD = ri[WS(ris, 10)]; + TE = ri[WS(ris, 21)]; + T1L = TD - TE; + T1M = ii[WS(iis, 10)]; + T1N = ii[WS(iis, 21)]; + T1O = T1M + T1N; + TF = TD + TE; + T50 = T1M - T1N; + T1P = T1L - T1O; + T1X = T1L + T1O; + } + } + { + E TC, TJ, T53, T56; + TC = Ty + TB; + TJ = TF + TI; + TK = TC + TJ; + T6g = TC - TJ; + T53 = TF - TI; + T56 = T54 - T55; + T57 = T53 + T56; + T5N = T56 - T53; + } + { + E T6h, T6i, T1K, T1V; + T6h = T55 + T54; + T6i = T50 + T4Z; + T6j = T6h - T6i; + T6N = T6i + T6h; + T1K = T1G - T1J; + T1V = KP707106781 * (T1P + T1U); + T1W = T1K + T1V; + T34 = T1K - T1V; + } + { + E T1Z, T24, T3H, T3I; + T1Z = KP707106781 * (T1X - T1Y); + T24 = T20 + T23; + T25 = T1Z + T24; + T35 = T24 - T1Z; + T3H = KP707106781 * (T1P - T1U); + T3I = T23 - T20; + T3J = T3H + T3I; + T4j = T3I - T3H; + } + { + E T4Y, T51, T3E, T3F; + T4Y = Ty - TB; + T51 = T4Z - T50; + T52 = T4Y + T51; + T5M = T4Y - T51; + T3E = T1G + T1J; + T3F = KP707106781 * (T1X + T1Y); + T3G = T3E - T3F; + T4i = T3E + T3F; + } + } + { + E TN, T27, T2u, T5f, TQ, T2r, T2a, T5g, TX, T5a, T2l, T2p, TU, T5b, T2g; + E T2o; + { + E TL, TM, T28, T29; + TL = ri[WS(ris, 1)]; + TM = ri[WS(ris, 30)]; + TN = TL + TM; + T27 = TL - TM; + { + E T2s, T2t, TO, TP; + T2s = ii[WS(iis, 1)]; + T2t = ii[WS(iis, 30)]; + T2u = T2s + T2t; + T5f = T2t - T2s; + TO = ri[WS(ris, 14)]; + TP = ri[WS(ris, 17)]; + TQ = TO + TP; + T2r = TO - TP; + } + T28 = ii[WS(iis, 14)]; + T29 = ii[WS(iis, 17)]; + T2a = T28 + T29; + T5g = T28 - T29; + { + E TV, TW, T2h, T2i, T2j, T2k; + TV = ri[WS(ris, 9)]; + TW = ri[WS(ris, 22)]; + T2h = TV - TW; + T2i = ii[WS(iis, 9)]; + T2j = ii[WS(iis, 22)]; + T2k = T2i + T2j; + TX = TV + TW; + T5a = T2j - T2i; + T2l = T2h - T2k; + T2p = T2h + T2k; + } + { + E TS, TT, T2c, T2d, T2e, T2f; + TS = ri[WS(ris, 6)]; + TT = ri[WS(ris, 25)]; + T2c = TS - TT; + T2d = ii[WS(iis, 6)]; + T2e = ii[WS(iis, 25)]; + T2f = T2d + T2e; + TU = TS + TT; + T5b = T2d - T2e; + T2g = T2c - T2f; + T2o = T2c + T2f; + } + } + { + E TR, TY, T5e, T5h; + TR = TN + TQ; + TY = TU + TX; + TZ = TR + TY; + T6l = TR - TY; + T5e = TU - TX; + T5h = T5f - T5g; + T5i = T5e + T5h; + T5Q = T5h - T5e; + } + { + E T6m, T6n, T2b, T2m; + T6m = T5g + T5f; + T6n = T5b + T5a; + T6o = T6m - T6n; + T6M = T6n + T6m; + T2b = T27 - T2a; + T2m = KP707106781 * (T2g + T2l); + T2n = T2b + T2m; + T37 = T2b - T2m; + } + { + E T2q, T2v, T3O, T3P; + T2q = KP707106781 * (T2o - T2p); + T2v = T2r - T2u; + T2w = T2q + T2v; + T38 = T2v - T2q; + T3O = KP707106781 * (T2g - T2l); + T3P = T2r + T2u; + T3Q = T3O - T3P; + T4m = T3O + T3P; + } + { + E T59, T5c, T3L, T3M; + T59 = TN - TQ; + T5c = T5a - T5b; + T5d = T59 + T5c; + T5P = T59 - T5c; + T3L = T27 + T2a; + T3M = KP707106781 * (T2o + T2p); + T3N = T3L - T3M; + T4l = T3L + T3M; + } + } + { + E Tv, T10, T6X, T6Y, T6Z, T70; + Tv = Tf + Tu; + T10 = TK + TZ; + T6X = Tv - T10; + T6Y = T6N + T6M; + T6Z = T6R - T6Q; + T70 = T6Y + T6Z; + O[0] = KP2_000000000 * (Tv + T10); + O[WS(os, 32)] = KP2_000000000 * (T6Z - T6Y); + O[WS(os, 16)] = KP1_414213562 * (T6X + T70); + O[WS(os, 48)] = KP1_414213562 * (T70 - T6X); + } + { + E T6P, T6V, T6U, T6W; + { + E T6L, T6O, T6S, T6T; + T6L = Tf - Tu; + T6O = T6M - T6N; + T6P = T6L + T6O; + T6V = T6L - T6O; + T6S = T6Q + T6R; + T6T = TK - TZ; + T6U = T6S - T6T; + T6W = T6T + T6S; + } + O[WS(os, 8)] = FMA(KP1_847759065, T6P, KP765366864 * T6U); + O[WS(os, 56)] = FNMS(KP1_847759065, T6V, KP765366864 * T6W); + O[WS(os, 40)] = FNMS(KP765366864, T6P, KP1_847759065 * T6U); + O[WS(os, 24)] = FMA(KP765366864, T6V, KP1_847759065 * T6W); + } + { + E T6f, T6w, T6G, T6D, T6z, T6E, T6q, T6H; + T6f = T6b + T6e; + T6w = T6u - T6v; + T6G = T6v + T6u; + T6D = T6b - T6e; + { + E T6x, T6y, T6k, T6p; + T6x = T6g + T6j; + T6y = T6o - T6l; + T6z = KP707106781 * (T6x + T6y); + T6E = KP707106781 * (T6y - T6x); + T6k = T6g - T6j; + T6p = T6l + T6o; + T6q = KP707106781 * (T6k + T6p); + T6H = KP707106781 * (T6k - T6p); + } + { + E T6r, T6A, T6J, T6K; + T6r = T6f + T6q; + T6A = T6w - T6z; + O[WS(os, 4)] = FMA(KP1_961570560, T6r, KP390180644 * T6A); + O[WS(os, 36)] = FNMS(KP390180644, T6r, KP1_961570560 * T6A); + T6J = T6D - T6E; + T6K = T6H + T6G; + O[WS(os, 28)] = FMA(KP390180644, T6J, KP1_961570560 * T6K); + O[WS(os, 60)] = FNMS(KP1_961570560, T6J, KP390180644 * T6K); + } + { + E T6B, T6C, T6F, T6I; + T6B = T6f - T6q; + T6C = T6z + T6w; + O[WS(os, 20)] = FMA(KP1_111140466, T6B, KP1_662939224 * T6C); + O[WS(os, 52)] = FNMS(KP1_662939224, T6B, KP1_111140466 * T6C); + T6F = T6D + T6E; + T6I = T6G - T6H; + O[WS(os, 12)] = FMA(KP1_662939224, T6F, KP1_111140466 * T6I); + O[WS(os, 44)] = FNMS(KP1_111140466, T6F, KP1_662939224 * T6I); + } + } + { + E T5L, T63, T5W, T66, T5S, T67, T5Z, T64, T5K, T5V; + T5K = KP707106781 * (T5s - T5r); + T5L = T5J + T5K; + T63 = T5J - T5K; + T5V = KP707106781 * (T4Q - T4V); + T5W = T5U - T5V; + T66 = T5V + T5U; + { + E T5O, T5R, T5X, T5Y; + T5O = FNMS(KP923879532, T5N, KP382683432 * T5M); + T5R = FMA(KP382683432, T5P, KP923879532 * T5Q); + T5S = T5O + T5R; + T67 = T5O - T5R; + T5X = FMA(KP923879532, T5M, KP382683432 * T5N); + T5Y = FNMS(KP923879532, T5P, KP382683432 * T5Q); + T5Z = T5X + T5Y; + T64 = T5Y - T5X; + } + { + E T5T, T60, T69, T6a; + T5T = T5L + T5S; + T60 = T5W - T5Z; + O[WS(os, 6)] = FMA(KP1_913880671, T5T, KP580569354 * T60); + O[WS(os, 38)] = FNMS(KP580569354, T5T, KP1_913880671 * T60); + T69 = T63 - T64; + T6a = T67 + T66; + O[WS(os, 30)] = FMA(KP196034280, T69, KP1_990369453 * T6a); + O[WS(os, 62)] = FNMS(KP1_990369453, T69, KP196034280 * T6a); + } + { + E T61, T62, T65, T68; + T61 = T5L - T5S; + T62 = T5Z + T5W; + O[WS(os, 22)] = FMA(KP942793473, T61, KP1_763842528 * T62); + O[WS(os, 54)] = FNMS(KP1_763842528, T61, KP942793473 * T62); + T65 = T63 + T64; + T68 = T66 - T67; + O[WS(os, 14)] = FMA(KP1_546020906, T65, KP1_268786568 * T68); + O[WS(os, 46)] = FNMS(KP1_268786568, T65, KP1_546020906 * T68); + } + } + { + E T4X, T5B, T5u, T5E, T5k, T5F, T5x, T5C, T4W, T5t; + T4W = KP707106781 * (T4Q + T4V); + T4X = T4L + T4W; + T5B = T4L - T4W; + T5t = KP707106781 * (T5r + T5s); + T5u = T5q - T5t; + T5E = T5t + T5q; + { + E T58, T5j, T5v, T5w; + T58 = FNMS(KP382683432, T57, KP923879532 * T52); + T5j = FMA(KP923879532, T5d, KP382683432 * T5i); + T5k = T58 + T5j; + T5F = T58 - T5j; + T5v = FMA(KP382683432, T52, KP923879532 * T57); + T5w = FNMS(KP382683432, T5d, KP923879532 * T5i); + T5x = T5v + T5w; + T5C = T5w - T5v; + } + { + E T5l, T5y, T5H, T5I; + T5l = T4X + T5k; + T5y = T5u - T5x; + O[WS(os, 2)] = FMA(KP1_990369453, T5l, KP196034280 * T5y); + O[WS(os, 34)] = FNMS(KP196034280, T5l, KP1_990369453 * T5y); + T5H = T5B - T5C; + T5I = T5F + T5E; + O[WS(os, 26)] = FMA(KP580569354, T5H, KP1_913880671 * T5I); + O[WS(os, 58)] = FNMS(KP1_913880671, T5H, KP580569354 * T5I); + } + { + E T5z, T5A, T5D, T5G; + T5z = T4X - T5k; + T5A = T5x + T5u; + O[WS(os, 18)] = FMA(KP1_268786568, T5z, KP1_546020906 * T5A); + O[WS(os, 50)] = FNMS(KP1_546020906, T5z, KP1_268786568 * T5A); + T5D = T5B + T5C; + T5G = T5E - T5F; + O[WS(os, 10)] = FMA(KP1_763842528, T5D, KP942793473 * T5G); + O[WS(os, 42)] = FNMS(KP942793473, T5D, KP1_763842528 * T5G); + } + } + { + E T33, T3l, T3h, T3m, T3a, T3p, T3e, T3o; + { + E T31, T32, T3f, T3g; + T31 = T15 - T1g; + T32 = T2E - T2D; + T33 = T31 + T32; + T3l = T31 - T32; + T3f = FMA(KP831469612, T34, KP555570233 * T35); + T3g = FNMS(KP831469612, T37, KP555570233 * T38); + T3h = T3f + T3g; + T3m = T3g - T3f; + } + { + E T36, T39, T3c, T3d; + T36 = FNMS(KP831469612, T35, KP555570233 * T34); + T39 = FMA(KP555570233, T37, KP831469612 * T38); + T3a = T36 + T39; + T3p = T36 - T39; + T3c = T2I - T2N; + T3d = T1s - T1D; + T3e = T3c - T3d; + T3o = T3d + T3c; + } + { + E T3b, T3i, T3r, T3s; + T3b = T33 + T3a; + T3i = T3e - T3h; + O[WS(os, 5)] = FMA(KP1_940062506, T3b, KP485960359 * T3i); + O[WS(os, 37)] = FNMS(KP485960359, T3b, KP1_940062506 * T3i); + T3r = T3l - T3m; + T3s = T3p + T3o; + O[WS(os, 29)] = FMA(KP293460948, T3r, KP1_978353019 * T3s); + O[WS(os, 61)] = FNMS(KP1_978353019, T3r, KP293460948 * T3s); + } + { + E T3j, T3k, T3n, T3q; + T3j = T33 - T3a; + T3k = T3h + T3e; + O[WS(os, 21)] = FMA(KP1_028205488, T3j, KP1_715457220 * T3k); + O[WS(os, 53)] = FNMS(KP1_715457220, T3j, KP1_028205488 * T3k); + T3n = T3l + T3m; + T3q = T3o - T3p; + O[WS(os, 13)] = FMA(KP1_606415062, T3n, KP1_191398608 * T3q); + O[WS(os, 45)] = FNMS(KP1_191398608, T3n, KP1_606415062 * T3q); + } + } + { + E T4h, T4z, T4v, T4A, T4o, T4D, T4s, T4C; + { + E T4f, T4g, T4t, T4u; + T4f = T3t + T3u; + T4g = T3X + T3Y; + T4h = T4f - T4g; + T4z = T4f + T4g; + T4t = FMA(KP980785280, T4i, KP195090322 * T4j); + T4u = FMA(KP980785280, T4l, KP195090322 * T4m); + T4v = T4t - T4u; + T4A = T4t + T4u; + } + { + E T4k, T4n, T4q, T4r; + T4k = FNMS(KP980785280, T4j, KP195090322 * T4i); + T4n = FNMS(KP980785280, T4m, KP195090322 * T4l); + T4o = T4k + T4n; + T4D = T4k - T4n; + T4q = T3V + T3U; + T4r = T3y - T3B; + T4s = T4q - T4r; + T4C = T4r + T4q; + } + { + E T4p, T4w, T4F, T4G; + T4p = T4h + T4o; + T4w = T4s - T4v; + O[WS(os, 7)] = FMA(KP1_883088130, T4p, KP673779706 * T4w); + O[WS(os, 39)] = FNMS(KP673779706, T4p, KP1_883088130 * T4w); + T4F = T4z + T4A; + T4G = T4D + T4C; + O[WS(os, 31)] = FMA(KP098135348, T4F, KP1_997590912 * T4G); + O[WS(os, 63)] = FNMS(KP1_997590912, T4F, KP098135348 * T4G); + } + { + E T4x, T4y, T4B, T4E; + T4x = T4h - T4o; + T4y = T4v + T4s; + O[WS(os, 23)] = FMA(KP855110186, T4x, KP1_807978586 * T4y); + O[WS(os, 55)] = FNMS(KP1_807978586, T4x, KP855110186 * T4y); + T4B = T4z - T4A; + T4E = T4C - T4D; + O[WS(os, 15)] = FMA(KP1_481902250, T4B, KP1_343117909 * T4E); + O[WS(os, 47)] = FNMS(KP1_343117909, T4B, KP1_481902250 * T4E); + } + } + { + E T1F, T2T, T2P, T2W, T2y, T2X, T2C, T2U; + { + E T1h, T1E, T2F, T2O; + T1h = T15 + T1g; + T1E = T1s + T1D; + T1F = T1h + T1E; + T2T = T1h - T1E; + T2F = T2D + T2E; + T2O = T2I + T2N; + T2P = T2F + T2O; + T2W = T2F - T2O; + } + { + E T26, T2x, T2A, T2B; + T26 = FNMS(KP195090322, T25, KP980785280 * T1W); + T2x = FMA(KP980785280, T2n, KP195090322 * T2w); + T2y = T26 + T2x; + T2X = T26 - T2x; + T2A = FMA(KP195090322, T1W, KP980785280 * T25); + T2B = FNMS(KP195090322, T2n, KP980785280 * T2w); + T2C = T2A + T2B; + T2U = T2B - T2A; + } + { + E T2z, T2Q, T2Z, T30; + T2z = T1F + T2y; + T2Q = T2C + T2P; + O[WS(os, 1)] = FNMS(KP098135348, T2Q, KP1_997590912 * T2z); + O[WS(os, 33)] = -(FMA(KP098135348, T2z, KP1_997590912 * T2Q)); + T2Z = T2T - T2U; + T30 = T2X + T2W; + O[WS(os, 25)] = FMA(KP673779706, T2Z, KP1_883088130 * T30); + O[WS(os, 57)] = FNMS(KP1_883088130, T2Z, KP673779706 * T30); + } + { + E T2R, T2S, T2V, T2Y; + T2R = T1F - T2y; + T2S = T2C - T2P; + O[WS(os, 17)] = FMA(KP1_343117909, T2R, KP1_481902250 * T2S); + O[WS(os, 49)] = FNMS(KP1_481902250, T2R, KP1_343117909 * T2S); + T2V = T2T + T2U; + T2Y = T2W - T2X; + O[WS(os, 9)] = FMA(KP1_807978586, T2V, KP855110186 * T2Y); + O[WS(os, 41)] = FNMS(KP855110186, T2V, KP1_807978586 * T2Y); + } + } + { + E T3D, T47, T43, T48, T3S, T4b, T40, T4a; + { + E T3v, T3C, T41, T42; + T3v = T3t - T3u; + T3C = T3y + T3B; + T3D = T3v + T3C; + T47 = T3v - T3C; + T41 = FMA(KP555570233, T3G, KP831469612 * T3J); + T42 = FNMS(KP555570233, T3N, KP831469612 * T3Q); + T43 = T41 + T42; + T48 = T42 - T41; + } + { + E T3K, T3R, T3W, T3Z; + T3K = FNMS(KP555570233, T3J, KP831469612 * T3G); + T3R = FMA(KP831469612, T3N, KP555570233 * T3Q); + T3S = T3K + T3R; + T4b = T3K - T3R; + T3W = T3U - T3V; + T3Z = T3X - T3Y; + T40 = T3W - T3Z; + T4a = T3Z + T3W; + } + { + E T3T, T44, T4d, T4e; + T3T = T3D + T3S; + T44 = T40 - T43; + O[WS(os, 3)] = FMA(KP1_978353019, T3T, KP293460948 * T44); + O[WS(os, 35)] = FNMS(KP293460948, T3T, KP1_978353019 * T44); + T4d = T47 - T48; + T4e = T4b + T4a; + O[WS(os, 27)] = FMA(KP485960359, T4d, KP1_940062506 * T4e); + O[WS(os, 59)] = FNMS(KP1_940062506, T4d, KP485960359 * T4e); + } + { + E T45, T46, T49, T4c; + T45 = T3D - T3S; + T46 = T43 + T40; + O[WS(os, 19)] = FMA(KP1_191398608, T45, KP1_606415062 * T46); + O[WS(os, 51)] = FNMS(KP1_606415062, T45, KP1_191398608 * T46); + T49 = T47 + T48; + T4c = T4a - T4b; + O[WS(os, 11)] = FMA(KP1_715457220, T49, KP1_028205488 * T4c); + O[WS(os, 43)] = FNMS(KP1_028205488, T49, KP1_715457220 * T4c); + } + } + } +} + +static void mhc2rIII_64(const R *ri, const R *ii, R *O, stride ris, stride iis, stride os, int v, int ivs, int ovs) +{ + int i; + for (i = v; i > 0; --i) { + mhc2rIII_64_0(ri, ii, O, ris, iis, os); + ri += ivs; + ii += ivs; + O += ovs; + } +} + +static const khc2r_desc desc = { 64, "mhc2rIII_64", {342, 116, 92, 0}, &GENUS, 0, 0, 0, 0, 0 }; + +void X(codelet_mhc2rIII_64) (planner *p) { + X(khc2rIII_register) (p, mhc2rIII_64, &desc); +} diff --git a/src/fftw3/rdft/codelets/hc2r/mhc2r_128.c b/src/fftw3/rdft/codelets/hc2r/mhc2r_128.c new file mode 100644 index 0000000..27209a3 --- /dev/null +++ b/src/fftw3/rdft/codelets/hc2r/mhc2r_128.c @@ -0,0 +1,1652 @@ +/* + * Copyright (c) 2003 Matteo Frigo + * Copyright (c) 2003 Massachusetts Institute of Technology + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +/* This file was automatically generated --- DO NOT EDIT */ +/* Generated on Sat Jul 5 22:11:20 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_hc2r_noinline -compact -variables 4 -sign 1 -n 128 -name mhc2r_128 -include hc2r.h */ + +/* + * This function contains 956 FP additions, 342 FP multiplications, + * (or, 812 additions, 198 multiplications, 144 fused multiply/add), + * 197 stack variables, and 256 memory accesses + */ +/* + * Generator Id's : + * $Id: mhc2r_128.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: mhc2r_128.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: mhc2r_128.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + */ + +#include "hc2r.h" + +static void mhc2r_128_0(const R *ri, const R *ii, R *O, stride ris, stride iis, stride os) +{ + DK(KP1_028205488, +1.028205488386443453187387677937631545216098241); + DK(KP1_715457220, +1.715457220000544139804539968569540274084981599); + DK(KP1_606415062, +1.606415062961289819613353025926283847759138854); + DK(KP1_191398608, +1.191398608984866686934073057659939779023852677); + DK(KP1_940062506, +1.940062506389087985207968414572200502913731924); + DK(KP485960359, +0.485960359806527779896548324154942236641981567); + DK(KP293460948, +0.293460948910723503317700259293435639412430633); + DK(KP1_978353019, +1.978353019929561946903347476032486127967379067); + DK(KP831469612, +0.831469612302545237078788377617905756738560812); + DK(KP555570233, +0.555570233019602224742830813948532874374937191); + DK(KP855110186, +0.855110186860564188641933713777597068609157259); + DK(KP1_807978586, +1.807978586246886663172400594461074097420264050); + DK(KP1_481902250, +1.481902250709918182351233794990325459457910619); + DK(KP1_343117909, +1.343117909694036801250753700854843606457501264); + DK(KP1_883088130, +1.883088130366041556825018805199004714371179592); + DK(KP673779706, +0.673779706784440101378506425238295140955533559); + DK(KP098135348, +0.098135348654836028509909953885365316629490726); + DK(KP1_997590912, +1.997590912410344785429543209518201388886407229); + DK(KP980785280, +0.980785280403230449126182236134239036973933731); + DK(KP195090322, +0.195090322016128267848284868477022240927691618); + DK(KP580569354, +0.580569354508924735272384751634790549382952557); + DK(KP1_913880671, +1.913880671464417729871595773960539938965698411); + DK(KP942793473, +0.942793473651995297112775251810508755314920638); + DK(KP1_763842528, +1.763842528696710059425513727320776699016885241); + DK(KP1_111140466, +1.111140466039204449485661627897065748749874382); + DK(KP1_662939224, +1.662939224605090474157576755235811513477121624); + DK(KP1_268786568, +1.268786568327290996430343226450986741351374190); + DK(KP1_546020906, +1.546020906725473921621813219516939601942082586); + DK(KP196034280, +0.196034280659121203988391127777283691722273346); + DK(KP1_990369453, +1.990369453344393772489673906218959843150949737); + DK(KP390180644, +0.390180644032256535696569736954044481855383236); + DK(KP1_961570560, +1.961570560806460898252364472268478073947867462); + DK(KP382683432, +0.382683432365089771728459984030398866761344562); + DK(KP923879532, +0.923879532511286756128183189396788286822416626); + DK(KP707106781, +0.707106781186547524400844362104849039284835938); + DK(KP765366864, +0.765366864730179543456919968060797733522689125); + DK(KP1_847759065, +1.847759065022573512256366378793576573644833252); + DK(KP1_414213562, +1.414213562373095048801688724209698078569671875); + DK(KP2_000000000, +2.000000000000000000000000000000000000000000000); + { + E Ta, T6q, T2a, T5k, T8x, Tbx, TcF, Ten, Th, T6r, T2j, T5l, T8E, Tby, TcI; + E Teo, Tx, T6t, TcM, Teq, TcP, Ter, T2t, T5n, T2C, T5o, T8Q, TbA, T8X, TbB; + E T6w, T7L, T1j, T6L, Tde, TeC, TdL, TeR, T3v, T5z, T4I, T5O, T9O, TbM, TaV; + E Tc1, T78, T7Z, TN, T6z, TcU, Teu, Td8, Tey, T2N, T5r, T3j, T5v, T9a, TbE; + E T9A, TbI, T6H, T7O, T1O, T7V, T48, T4u, Tds, TeG, T5E, T5K, Taf, TbP, Tdp; + E TeF, T6U, T72, Tam, TbQ, T23, T7U, T4r, T4v, Tdz, TeJ, T5H, T5L, Tay, TbS; + E Tdw, TeI, T6Z, T73, TaF, TbT, T1y, T75, Tdl, TeQ, TdI, TeD, T3O, T5N, T4z; + E T5A, Ta3, Tc0, TaO, TbN, T6O, T80, T12, T6E, Td1, Tex, Td5, Tev, T36, T5u; + E T3a, T5s, T9p, TbH, T9t, TbF, T6C, T7P; + { + E T5, T8s, T3, T8q, T9, T8u, T29, T8v, T6, T26; + { + E T4, T8r, T1, T2; + T4 = ri[WS(ris, 32)]; + T5 = KP2_000000000 * T4; + T8r = ii[WS(iis, 32)]; + T8s = KP2_000000000 * T8r; + T1 = ri[0]; + T2 = ri[WS(ris, 64)]; + T3 = T1 + T2; + T8q = T1 - T2; + { + E T7, T8, T27, T28; + T7 = ri[WS(ris, 16)]; + T8 = ri[WS(ris, 48)]; + T9 = KP2_000000000 * (T7 + T8); + T8u = T7 - T8; + T27 = ii[WS(iis, 16)]; + T28 = ii[WS(iis, 48)]; + T29 = KP2_000000000 * (T27 - T28); + T8v = T27 + T28; + } + } + T6 = T3 + T5; + Ta = T6 + T9; + T6q = T6 - T9; + T26 = T3 - T5; + T2a = T26 - T29; + T5k = T26 + T29; + { + E T8t, T8w, TcD, TcE; + T8t = T8q - T8s; + T8w = KP1_414213562 * (T8u - T8v); + T8x = T8t + T8w; + Tbx = T8t - T8w; + TcD = T8q + T8s; + TcE = KP1_414213562 * (T8u + T8v); + TcF = TcD - TcE; + Ten = TcD + TcE; + } + } + { + E Td, T8y, T2e, T8C, Tg, T8B, T2h, T8z, T2b, T2i; + { + E Tb, Tc, T2c, T2d; + Tb = ri[WS(ris, 8)]; + Tc = ri[WS(ris, 56)]; + Td = Tb + Tc; + T8y = Tb - Tc; + T2c = ii[WS(iis, 8)]; + T2d = ii[WS(iis, 56)]; + T2e = T2c - T2d; + T8C = T2c + T2d; + } + { + E Te, Tf, T2f, T2g; + Te = ri[WS(ris, 40)]; + Tf = ri[WS(ris, 24)]; + Tg = Te + Tf; + T8B = Te - Tf; + T2f = ii[WS(iis, 40)]; + T2g = ii[WS(iis, 24)]; + T2h = T2f - T2g; + T8z = T2f + T2g; + } + Th = KP2_000000000 * (Td + Tg); + T6r = KP2_000000000 * (T2h + T2e); + T2b = Td - Tg; + T2i = T2e - T2h; + T2j = KP1_414213562 * (T2b - T2i); + T5l = KP1_414213562 * (T2b + T2i); + { + E T8A, T8D, TcG, TcH; + T8A = T8y - T8z; + T8D = T8B + T8C; + T8E = FNMS(KP765366864, T8D, KP1_847759065 * T8A); + Tby = FMA(KP765366864, T8A, KP1_847759065 * T8D); + TcG = T8y + T8z; + TcH = T8C - T8B; + TcI = FNMS(KP1_847759065, TcH, KP765366864 * TcG); + Teo = FMA(KP1_847759065, TcG, KP765366864 * TcH); + } + } + { + E Tl, T8G, T2x, T8V, To, T8U, T2A, T8H, Tv, T8S, T2o, T8O, Ts, T8R, T2r; + E T8L; + { + E Tj, Tk, T2y, T2z; + Tj = ri[WS(ris, 4)]; + Tk = ri[WS(ris, 60)]; + Tl = Tj + Tk; + T8G = Tj - Tk; + { + E T2v, T2w, Tm, Tn; + T2v = ii[WS(iis, 4)]; + T2w = ii[WS(iis, 60)]; + T2x = T2v - T2w; + T8V = T2v + T2w; + Tm = ri[WS(ris, 36)]; + Tn = ri[WS(ris, 28)]; + To = Tm + Tn; + T8U = Tm - Tn; + } + T2y = ii[WS(iis, 36)]; + T2z = ii[WS(iis, 28)]; + T2A = T2y - T2z; + T8H = T2y + T2z; + { + E Tt, Tu, T8M, T2m, T2n, T8N; + Tt = ri[WS(ris, 12)]; + Tu = ri[WS(ris, 52)]; + T8M = Tt - Tu; + T2m = ii[WS(iis, 52)]; + T2n = ii[WS(iis, 12)]; + T8N = T2n + T2m; + Tv = Tt + Tu; + T8S = T8M + T8N; + T2o = T2m - T2n; + T8O = T8M - T8N; + } + { + E Tq, Tr, T8J, T2p, T2q, T8K; + Tq = ri[WS(ris, 20)]; + Tr = ri[WS(ris, 44)]; + T8J = Tq - Tr; + T2p = ii[WS(iis, 20)]; + T2q = ii[WS(iis, 44)]; + T8K = T2p + T2q; + Ts = Tq + Tr; + T8R = T8J + T8K; + T2r = T2p - T2q; + T8L = T8J - T8K; + } + } + { + E Tp, Tw, TcK, TcL; + Tp = Tl + To; + Tw = Ts + Tv; + Tx = KP2_000000000 * (Tp + Tw); + T6t = Tp - Tw; + TcK = T8G + T8H; + TcL = KP707106781 * (T8R + T8S); + TcM = TcK - TcL; + Teq = TcK + TcL; + } + { + E TcN, TcO, T2l, T2s; + TcN = KP707106781 * (T8L - T8O); + TcO = T8V - T8U; + TcP = TcN + TcO; + Ter = TcO - TcN; + T2l = Tl - To; + T2s = T2o - T2r; + T2t = T2l + T2s; + T5n = T2l - T2s; + } + { + E T2u, T2B, T8I, T8P; + T2u = Ts - Tv; + T2B = T2x - T2A; + T2C = T2u + T2B; + T5o = T2B - T2u; + T8I = T8G - T8H; + T8P = KP707106781 * (T8L + T8O); + T8Q = T8I + T8P; + TbA = T8I - T8P; + } + { + E T8T, T8W, T6u, T6v; + T8T = KP707106781 * (T8R - T8S); + T8W = T8U + T8V; + T8X = T8T + T8W; + TbB = T8W - T8T; + T6u = T2A + T2x; + T6v = T2r + T2o; + T6w = T6u - T6v; + T7L = KP2_000000000 * (T6v + T6u); + } + } + { + E T17, T9E, T4D, TaT, T1a, TaS, T4G, T9F, T1h, TaQ, T3q, T9M, T1e, TaP, T3t; + E T9J; + { + E T15, T16, T4E, T4F; + T15 = ri[WS(ris, 1)]; + T16 = ri[WS(ris, 63)]; + T17 = T15 + T16; + T9E = T15 - T16; + { + E T4B, T4C, T18, T19; + T4B = ii[WS(iis, 1)]; + T4C = ii[WS(iis, 63)]; + T4D = T4B - T4C; + TaT = T4B + T4C; + T18 = ri[WS(ris, 33)]; + T19 = ri[WS(ris, 31)]; + T1a = T18 + T19; + TaS = T18 - T19; + } + T4E = ii[WS(iis, 33)]; + T4F = ii[WS(iis, 31)]; + T4G = T4E - T4F; + T9F = T4E + T4F; + { + E T1f, T1g, T9K, T3o, T3p, T9L; + T1f = ri[WS(ris, 15)]; + T1g = ri[WS(ris, 49)]; + T9K = T1f - T1g; + T3o = ii[WS(iis, 49)]; + T3p = ii[WS(iis, 15)]; + T9L = T3p + T3o; + T1h = T1f + T1g; + TaQ = T9K + T9L; + T3q = T3o - T3p; + T9M = T9K - T9L; + } + { + E T1c, T1d, T9H, T3r, T3s, T9I; + T1c = ri[WS(ris, 17)]; + T1d = ri[WS(ris, 47)]; + T9H = T1c - T1d; + T3r = ii[WS(iis, 17)]; + T3s = ii[WS(iis, 47)]; + T9I = T3r + T3s; + T1e = T1c + T1d; + TaP = T9H + T9I; + T3t = T3r - T3s; + T9J = T9H - T9I; + } + } + { + E T1b, T1i, Tdc, Tdd; + T1b = T17 + T1a; + T1i = T1e + T1h; + T1j = T1b + T1i; + T6L = T1b - T1i; + Tdc = T9E + T9F; + Tdd = KP707106781 * (TaP + TaQ); + Tde = Tdc - Tdd; + TeC = Tdc + Tdd; + } + { + E TdJ, TdK, T3n, T3u; + TdJ = KP707106781 * (T9J - T9M); + TdK = TaT - TaS; + TdL = TdJ + TdK; + TeR = TdK - TdJ; + T3n = T17 - T1a; + T3u = T3q - T3t; + T3v = T3n + T3u; + T5z = T3n - T3u; + } + { + E T4A, T4H, T9G, T9N; + T4A = T1e - T1h; + T4H = T4D - T4G; + T4I = T4A + T4H; + T5O = T4H - T4A; + T9G = T9E - T9F; + T9N = KP707106781 * (T9J + T9M); + T9O = T9G + T9N; + TbM = T9G - T9N; + } + { + E TaR, TaU, T76, T77; + TaR = KP707106781 * (TaP - TaQ); + TaU = TaS + TaT; + TaV = TaR + TaU; + Tc1 = TaU - TaR; + T76 = T4G + T4D; + T77 = T3t + T3q; + T78 = T76 - T77; + T7Z = T77 + T76; + } + } + { + E TB, T90, T3e, T9y, TE, T9x, T3h, T91, TL, T9v, T2I, T98, TI, T9u, T2L; + E T95; + { + E Tz, TA, T3f, T3g; + Tz = ri[WS(ris, 2)]; + TA = ri[WS(ris, 62)]; + TB = Tz + TA; + T90 = Tz - TA; + { + E T3c, T3d, TC, TD; + T3c = ii[WS(iis, 2)]; + T3d = ii[WS(iis, 62)]; + T3e = T3c - T3d; + T9y = T3c + T3d; + TC = ri[WS(ris, 34)]; + TD = ri[WS(ris, 30)]; + TE = TC + TD; + T9x = TC - TD; + } + T3f = ii[WS(iis, 34)]; + T3g = ii[WS(iis, 30)]; + T3h = T3f - T3g; + T91 = T3f + T3g; + { + E TJ, TK, T96, T2G, T2H, T97; + TJ = ri[WS(ris, 14)]; + TK = ri[WS(ris, 50)]; + T96 = TJ - TK; + T2G = ii[WS(iis, 50)]; + T2H = ii[WS(iis, 14)]; + T97 = T2H + T2G; + TL = TJ + TK; + T9v = T96 + T97; + T2I = T2G - T2H; + T98 = T96 - T97; + } + { + E TG, TH, T93, T2J, T2K, T94; + TG = ri[WS(ris, 18)]; + TH = ri[WS(ris, 46)]; + T93 = TG - TH; + T2J = ii[WS(iis, 18)]; + T2K = ii[WS(iis, 46)]; + T94 = T2J + T2K; + TI = TG + TH; + T9u = T93 + T94; + T2L = T2J - T2K; + T95 = T93 - T94; + } + } + { + E TF, TM, TcS, TcT; + TF = TB + TE; + TM = TI + TL; + TN = TF + TM; + T6z = TF - TM; + TcS = T90 + T91; + TcT = KP707106781 * (T9u + T9v); + TcU = TcS - TcT; + Teu = TcS + TcT; + } + { + E Td6, Td7, T2F, T2M; + Td6 = KP707106781 * (T95 - T98); + Td7 = T9y - T9x; + Td8 = Td6 + Td7; + Tey = Td7 - Td6; + T2F = TB - TE; + T2M = T2I - T2L; + T2N = T2F + T2M; + T5r = T2F - T2M; + } + { + E T3b, T3i, T92, T99; + T3b = TI - TL; + T3i = T3e - T3h; + T3j = T3b + T3i; + T5v = T3i - T3b; + T92 = T90 - T91; + T99 = KP707106781 * (T95 + T98); + T9a = T92 + T99; + TbE = T92 - T99; + } + { + E T9w, T9z, T6F, T6G; + T9w = KP707106781 * (T9u - T9v); + T9z = T9x + T9y; + T9A = T9w + T9z; + TbI = T9z - T9w; + T6F = T3h + T3e; + T6G = T2L + T2I; + T6H = T6F - T6G; + T7O = T6G + T6F; + } + } + { + E T1G, Taj, T3Q, Ta5, T46, Tak, T6R, Ta6, T1N, Tag, Tah, T3X, T3Z, Taa, Tad; + E T6S, Tdn, Tdo; + { + E T1A, T1B, T1C, T1D, T1E, T1F; + T1A = ri[WS(ris, 5)]; + T1B = ri[WS(ris, 59)]; + T1C = T1A + T1B; + T1D = ri[WS(ris, 37)]; + T1E = ri[WS(ris, 27)]; + T1F = T1D + T1E; + T1G = T1C + T1F; + Taj = T1D - T1E; + T3Q = T1C - T1F; + Ta5 = T1A - T1B; + } + { + E T40, T41, T42, T43, T44, T45; + T40 = ii[WS(iis, 5)]; + T41 = ii[WS(iis, 59)]; + T42 = T40 - T41; + T43 = ii[WS(iis, 37)]; + T44 = ii[WS(iis, 27)]; + T45 = T43 - T44; + T46 = T42 - T45; + Tak = T40 + T41; + T6R = T45 + T42; + Ta6 = T43 + T44; + } + { + E T1J, Ta8, T3W, Ta9, T1M, Tab, T3T, Tac; + { + E T1H, T1I, T3U, T3V; + T1H = ri[WS(ris, 21)]; + T1I = ri[WS(ris, 43)]; + T1J = T1H + T1I; + Ta8 = T1H - T1I; + T3U = ii[WS(iis, 21)]; + T3V = ii[WS(iis, 43)]; + T3W = T3U - T3V; + Ta9 = T3U + T3V; + } + { + E T1K, T1L, T3R, T3S; + T1K = ri[WS(ris, 11)]; + T1L = ri[WS(ris, 53)]; + T1M = T1K + T1L; + Tab = T1K - T1L; + T3R = ii[WS(iis, 53)]; + T3S = ii[WS(iis, 11)]; + T3T = T3R - T3S; + Tac = T3S + T3R; + } + T1N = T1J + T1M; + Tag = Ta8 + Ta9; + Tah = Tab + Tac; + T3X = T3T - T3W; + T3Z = T1J - T1M; + Taa = Ta8 - Ta9; + Tad = Tab - Tac; + T6S = T3W + T3T; + } + T1O = T1G + T1N; + T7V = T6S + T6R; + { + E T3Y, T47, Tdq, Tdr; + T3Y = T3Q + T3X; + T47 = T3Z + T46; + T48 = FNMS(KP382683432, T47, KP923879532 * T3Y); + T4u = FMA(KP382683432, T3Y, KP923879532 * T47); + Tdq = KP707106781 * (Taa - Tad); + Tdr = Tak - Taj; + Tds = Tdq + Tdr; + TeG = Tdr - Tdq; + } + { + E T5C, T5D, Ta7, Tae; + T5C = T3Q - T3X; + T5D = T46 - T3Z; + T5E = FNMS(KP923879532, T5D, KP382683432 * T5C); + T5K = FMA(KP923879532, T5C, KP382683432 * T5D); + Ta7 = Ta5 - Ta6; + Tae = KP707106781 * (Taa + Tad); + Taf = Ta7 + Tae; + TbP = Ta7 - Tae; + } + Tdn = Ta5 + Ta6; + Tdo = KP707106781 * (Tag + Tah); + Tdp = Tdn - Tdo; + TeF = Tdn + Tdo; + { + E T6Q, T6T, Tai, Tal; + T6Q = T1G - T1N; + T6T = T6R - T6S; + T6U = T6Q - T6T; + T72 = T6Q + T6T; + Tai = KP707106781 * (Tag - Tah); + Tal = Taj + Tak; + Tam = Tai + Tal; + TbQ = Tal - Tai; + } + } + { + E T1V, TaC, T49, Tao, T4p, TaD, T6W, Tap, T22, Taz, TaA, T4g, T4i, Tat, Taw; + E T6X, Tdu, Tdv; + { + E T1P, T1Q, T1R, T1S, T1T, T1U; + T1P = ri[WS(ris, 3)]; + T1Q = ri[WS(ris, 61)]; + T1R = T1P + T1Q; + T1S = ri[WS(ris, 29)]; + T1T = ri[WS(ris, 35)]; + T1U = T1S + T1T; + T1V = T1R + T1U; + TaC = T1S - T1T; + T49 = T1R - T1U; + Tao = T1P - T1Q; + } + { + E T4j, T4k, T4l, T4m, T4n, T4o; + T4j = ii[WS(iis, 61)]; + T4k = ii[WS(iis, 3)]; + T4l = T4j - T4k; + T4m = ii[WS(iis, 29)]; + T4n = ii[WS(iis, 35)]; + T4o = T4m - T4n; + T4p = T4l - T4o; + TaD = T4k + T4j; + T6W = T4o + T4l; + Tap = T4m + T4n; + } + { + E T1Y, Tar, T4f, Tas, T21, Tau, T4c, Tav; + { + E T1W, T1X, T4d, T4e; + T1W = ri[WS(ris, 13)]; + T1X = ri[WS(ris, 51)]; + T1Y = T1W + T1X; + Tar = T1W - T1X; + T4d = ii[WS(iis, 13)]; + T4e = ii[WS(iis, 51)]; + T4f = T4d - T4e; + Tas = T4d + T4e; + } + { + E T1Z, T20, T4a, T4b; + T1Z = ri[WS(ris, 19)]; + T20 = ri[WS(ris, 45)]; + T21 = T1Z + T20; + Tau = T1Z - T20; + T4a = ii[WS(iis, 45)]; + T4b = ii[WS(iis, 19)]; + T4c = T4a - T4b; + Tav = T4b + T4a; + } + T22 = T1Y + T21; + Taz = Tar + Tas; + TaA = Tau + Tav; + T4g = T4c - T4f; + T4i = T1Y - T21; + Tat = Tar - Tas; + Taw = Tau - Tav; + T6X = T4f + T4c; + } + T23 = T1V + T22; + T7U = T6X + T6W; + { + E T4h, T4q, Tdx, Tdy; + T4h = T49 + T4g; + T4q = T4i + T4p; + T4r = FMA(KP923879532, T4h, KP382683432 * T4q); + T4v = FNMS(KP382683432, T4h, KP923879532 * T4q); + Tdx = KP707106781 * (Tat - Taw); + Tdy = TaC + TaD; + Tdz = Tdx - Tdy; + TeJ = Tdx + Tdy; + } + { + E T5F, T5G, Taq, Tax; + T5F = T49 - T4g; + T5G = T4p - T4i; + T5H = FMA(KP382683432, T5F, KP923879532 * T5G); + T5L = FNMS(KP923879532, T5F, KP382683432 * T5G); + Taq = Tao - Tap; + Tax = KP707106781 * (Tat + Taw); + Tay = Taq + Tax; + TbS = Taq - Tax; + } + Tdu = Tao + Tap; + Tdv = KP707106781 * (Taz + TaA); + Tdw = Tdu - Tdv; + TeI = Tdu + Tdv; + { + E T6V, T6Y, TaB, TaE; + T6V = T1V - T22; + T6Y = T6W - T6X; + T6Z = T6V + T6Y; + T73 = T6Y - T6V; + TaB = KP707106781 * (Taz - TaA); + TaE = TaC - TaD; + TaF = TaB + TaE; + TbT = TaE - TaB; + } + } + { + E T1m, T3z, T1p, T3C, T3w, T3D, Tdg, Tdf, T9U, T9R, T1t, T3I, T1w, T3L, T3F; + E T3M, Tdj, Tdi, Ta1, T9Y; + { + E T9P, T9T, T9S, T9Q; + { + E T1k, T1l, T3x, T3y; + T1k = ri[WS(ris, 9)]; + T1l = ri[WS(ris, 55)]; + T1m = T1k + T1l; + T9P = T1k - T1l; + T3x = ii[WS(iis, 9)]; + T3y = ii[WS(iis, 55)]; + T3z = T3x - T3y; + T9T = T3x + T3y; + } + { + E T1n, T1o, T3A, T3B; + T1n = ri[WS(ris, 41)]; + T1o = ri[WS(ris, 23)]; + T1p = T1n + T1o; + T9S = T1n - T1o; + T3A = ii[WS(iis, 41)]; + T3B = ii[WS(iis, 23)]; + T3C = T3A - T3B; + T9Q = T3A + T3B; + } + T3w = T1m - T1p; + T3D = T3z - T3C; + Tdg = T9T - T9S; + Tdf = T9P + T9Q; + T9U = T9S + T9T; + T9R = T9P - T9Q; + } + { + E T9W, Ta0, T9Z, T9X; + { + E T1r, T1s, T3G, T3H; + T1r = ri[WS(ris, 7)]; + T1s = ri[WS(ris, 57)]; + T1t = T1r + T1s; + T9W = T1r - T1s; + T3G = ii[WS(iis, 57)]; + T3H = ii[WS(iis, 7)]; + T3I = T3G - T3H; + Ta0 = T3H + T3G; + } + { + E T1u, T1v, T3J, T3K; + T1u = ri[WS(ris, 25)]; + T1v = ri[WS(ris, 39)]; + T1w = T1u + T1v; + T9Z = T1u - T1v; + T3J = ii[WS(iis, 25)]; + T3K = ii[WS(iis, 39)]; + T3L = T3J - T3K; + T9X = T3J + T3K; + } + T3F = T1t - T1w; + T3M = T3I - T3L; + Tdj = T9Z + Ta0; + Tdi = T9W + T9X; + Ta1 = T9Z - Ta0; + T9Y = T9W - T9X; + } + { + E T1q, T1x, Tdh, Tdk; + T1q = T1m + T1p; + T1x = T1t + T1w; + T1y = T1q + T1x; + T75 = T1q - T1x; + Tdh = FNMS(KP923879532, Tdg, KP382683432 * Tdf); + Tdk = FNMS(KP923879532, Tdj, KP382683432 * Tdi); + Tdl = Tdh + Tdk; + TeQ = Tdh - Tdk; + } + { + E TdG, TdH, T3E, T3N; + TdG = FMA(KP923879532, Tdf, KP382683432 * Tdg); + TdH = FMA(KP923879532, Tdi, KP382683432 * Tdj); + TdI = TdG - TdH; + TeD = TdG + TdH; + T3E = T3w - T3D; + T3N = T3F + T3M; + T3O = KP707106781 * (T3E + T3N); + T5N = KP707106781 * (T3E - T3N); + } + { + E T4x, T4y, T9V, Ta2; + T4x = T3w + T3D; + T4y = T3M - T3F; + T4z = KP707106781 * (T4x + T4y); + T5A = KP707106781 * (T4y - T4x); + T9V = FNMS(KP382683432, T9U, KP923879532 * T9R); + Ta2 = FMA(KP923879532, T9Y, KP382683432 * Ta1); + Ta3 = T9V + Ta2; + Tc0 = T9V - Ta2; + } + { + E TaM, TaN, T6M, T6N; + TaM = FMA(KP382683432, T9R, KP923879532 * T9U); + TaN = FNMS(KP382683432, T9Y, KP923879532 * Ta1); + TaO = TaM + TaN; + TbN = TaN - TaM; + T6M = T3L + T3I; + T6N = T3C + T3z; + T6O = T6M - T6N; + T80 = T6N + T6M; + } + } + { + E TQ, T2R, TT, T2U, T2O, T2V, TcW, TcV, T9g, T9d, TX, T30, T10, T33, T2X; + E T34, TcZ, TcY, T9n, T9k; + { + E T9b, T9f, T9e, T9c; + { + E TO, TP, T2P, T2Q; + TO = ri[WS(ris, 10)]; + TP = ri[WS(ris, 54)]; + TQ = TO + TP; + T9b = TO - TP; + T2P = ii[WS(iis, 10)]; + T2Q = ii[WS(iis, 54)]; + T2R = T2P - T2Q; + T9f = T2P + T2Q; + } + { + E TR, TS, T2S, T2T; + TR = ri[WS(ris, 42)]; + TS = ri[WS(ris, 22)]; + TT = TR + TS; + T9e = TR - TS; + T2S = ii[WS(iis, 42)]; + T2T = ii[WS(iis, 22)]; + T2U = T2S - T2T; + T9c = T2S + T2T; + } + T2O = TQ - TT; + T2V = T2R - T2U; + TcW = T9f - T9e; + TcV = T9b + T9c; + T9g = T9e + T9f; + T9d = T9b - T9c; + } + { + E T9i, T9m, T9l, T9j; + { + E TV, TW, T2Y, T2Z; + TV = ri[WS(ris, 6)]; + TW = ri[WS(ris, 58)]; + TX = TV + TW; + T9i = TV - TW; + T2Y = ii[WS(iis, 58)]; + T2Z = ii[WS(iis, 6)]; + T30 = T2Y - T2Z; + T9m = T2Z + T2Y; + } + { + E TY, TZ, T31, T32; + TY = ri[WS(ris, 26)]; + TZ = ri[WS(ris, 38)]; + T10 = TY + TZ; + T9l = TY - TZ; + T31 = ii[WS(iis, 26)]; + T32 = ii[WS(iis, 38)]; + T33 = T31 - T32; + T9j = T31 + T32; + } + T2X = TX - T10; + T34 = T30 - T33; + TcZ = T9l + T9m; + TcY = T9i + T9j; + T9n = T9l - T9m; + T9k = T9i - T9j; + } + { + E TU, T11, TcX, Td0; + TU = TQ + TT; + T11 = TX + T10; + T12 = TU + T11; + T6E = TU - T11; + TcX = FNMS(KP923879532, TcW, KP382683432 * TcV); + Td0 = FNMS(KP923879532, TcZ, KP382683432 * TcY); + Td1 = TcX + Td0; + Tex = TcX - Td0; + } + { + E Td3, Td4, T2W, T35; + Td3 = FMA(KP923879532, TcV, KP382683432 * TcW); + Td4 = FMA(KP923879532, TcY, KP382683432 * TcZ); + Td5 = Td3 - Td4; + Tev = Td3 + Td4; + T2W = T2O - T2V; + T35 = T2X + T34; + T36 = KP707106781 * (T2W + T35); + T5u = KP707106781 * (T2W - T35); + } + { + E T38, T39, T9h, T9o; + T38 = T2O + T2V; + T39 = T34 - T2X; + T3a = KP707106781 * (T38 + T39); + T5s = KP707106781 * (T39 - T38); + T9h = FNMS(KP382683432, T9g, KP923879532 * T9d); + T9o = FMA(KP923879532, T9k, KP382683432 * T9n); + T9p = T9h + T9o; + TbH = T9h - T9o; + } + { + E T9r, T9s, T6A, T6B; + T9r = FMA(KP382683432, T9d, KP923879532 * T9g); + T9s = FNMS(KP382683432, T9k, KP923879532 * T9n); + T9t = T9r + T9s; + TbF = T9s - T9r; + T6A = T33 + T30; + T6B = T2U + T2R; + T6C = T6A - T6B; + T7P = T6B + T6A; + } + } + { + E T13, T8f, Ty, T8e, T25, T8h, T8k, T8p, Ti, T14, T8o; + T13 = KP2_000000000 * (TN + T12); + T8f = KP2_000000000 * (T7P + T7O); + Ti = Ta + Th; + Ty = Ti + Tx; + T8e = Ti - Tx; + { + E T1z, T24, T8i, T8j; + T1z = T1j + T1y; + T24 = T1O + T23; + T25 = KP2_000000000 * (T1z + T24); + T8h = T1z - T24; + T8i = T80 + T7Z; + T8j = T7V + T7U; + T8k = T8i - T8j; + T8p = KP2_000000000 * (T8j + T8i); + } + T14 = Ty + T13; + O[WS(os, 64)] = T14 - T25; + O[0] = T14 + T25; + T8o = Ty - T13; + O[WS(os, 32)] = T8o - T8p; + O[WS(os, 96)] = T8o + T8p; + { + E T8g, T8l, T8m, T8n; + T8g = T8e - T8f; + T8l = KP1_414213562 * (T8h - T8k); + O[WS(os, 80)] = T8g - T8l; + O[WS(os, 16)] = T8g + T8l; + T8m = T8e + T8f; + T8n = KP1_414213562 * (T8h + T8k); + O[WS(os, 48)] = T8m - T8n; + O[WS(os, 112)] = T8m + T8n; + } + } + { + E T7M, T86, T82, T8a, T7R, T87, T7X, T89, T7K, T7Y, T81; + T7K = Ta - Th; + T7M = T7K - T7L; + T86 = T7K + T7L; + T7Y = T1O - T23; + T81 = T7Z - T80; + T82 = T7Y + T81; + T8a = T81 - T7Y; + { + E T7N, T7Q, T7T, T7W; + T7N = TN - T12; + T7Q = T7O - T7P; + T7R = KP1_414213562 * (T7N - T7Q); + T87 = KP1_414213562 * (T7N + T7Q); + T7T = T1j - T1y; + T7W = T7U - T7V; + T7X = T7T + T7W; + T89 = T7T - T7W; + } + { + E T7S, T83, T8c, T8d; + T7S = T7M + T7R; + T83 = FNMS(KP765366864, T82, KP1_847759065 * T7X); + O[WS(os, 72)] = T7S - T83; + O[WS(os, 8)] = T7S + T83; + T8c = T86 + T87; + T8d = FMA(KP1_847759065, T89, KP765366864 * T8a); + O[WS(os, 56)] = T8c - T8d; + O[WS(os, 120)] = T8c + T8d; + } + { + E T84, T85, T88, T8b; + T84 = T7M - T7R; + T85 = FMA(KP765366864, T7X, KP1_847759065 * T82); + O[WS(os, 40)] = T84 - T85; + O[WS(os, 104)] = T84 + T85; + T88 = T86 - T87; + T8b = FNMS(KP1_847759065, T8a, KP765366864 * T89); + O[WS(os, 88)] = T88 - T8b; + O[WS(os, 24)] = T88 + T8b; + } + } + { + E T2E, T4O, T4K, T4S, T3l, T4P, T4t, T4R; + { + E T2k, T2D, T4w, T4J; + T2k = T2a + T2j; + T2D = FNMS(KP765366864, T2C, KP1_847759065 * T2t); + T2E = T2k + T2D; + T4O = T2k - T2D; + T4w = T4u + T4v; + T4J = T4z + T4I; + T4K = T4w + T4J; + T4S = T4J - T4w; + } + { + E T37, T3k, T3P, T4s; + T37 = T2N + T36; + T3k = T3a + T3j; + T3l = FNMS(KP390180644, T3k, KP1_961570560 * T37); + T4P = FMA(KP390180644, T37, KP1_961570560 * T3k); + T3P = T3v + T3O; + T4s = T48 + T4r; + T4t = T3P + T4s; + T4R = T3P - T4s; + } + { + E T3m, T4L, T4U, T4V; + T3m = T2E + T3l; + T4L = FNMS(KP196034280, T4K, KP1_990369453 * T4t); + O[WS(os, 66)] = T3m - T4L; + O[WS(os, 2)] = T3m + T4L; + T4U = T4O + T4P; + T4V = FMA(KP1_546020906, T4R, KP1_268786568 * T4S); + O[WS(os, 50)] = T4U - T4V; + O[WS(os, 114)] = T4U + T4V; + } + { + E T4M, T4N, T4Q, T4T; + T4M = T2E - T3l; + T4N = FMA(KP196034280, T4t, KP1_990369453 * T4K); + O[WS(os, 34)] = T4M - T4N; + O[WS(os, 98)] = T4M + T4N; + T4Q = T4O - T4P; + T4T = FNMS(KP1_546020906, T4S, KP1_268786568 * T4R); + O[WS(os, 82)] = T4Q - T4T; + O[WS(os, 18)] = T4Q + T4T; + } + } + { + E T6y, T7e, T7a, T7i, T6J, T7f, T71, T7h; + { + E T6s, T6x, T74, T79; + T6s = T6q - T6r; + T6x = KP1_414213562 * (T6t - T6w); + T6y = T6s + T6x; + T7e = T6s - T6x; + T74 = KP707106781 * (T72 + T73); + T79 = T75 + T78; + T7a = T74 + T79; + T7i = T79 - T74; + } + { + E T6D, T6I, T6P, T70; + T6D = T6z + T6C; + T6I = T6E + T6H; + T6J = FNMS(KP765366864, T6I, KP1_847759065 * T6D); + T7f = FMA(KP765366864, T6D, KP1_847759065 * T6I); + T6P = T6L + T6O; + T70 = KP707106781 * (T6U + T6Z); + T71 = T6P + T70; + T7h = T6P - T70; + } + { + E T6K, T7b, T7k, T7l; + T6K = T6y + T6J; + T7b = FNMS(KP390180644, T7a, KP1_961570560 * T71); + O[WS(os, 68)] = T6K - T7b; + O[WS(os, 4)] = T6K + T7b; + T7k = T7e + T7f; + T7l = FMA(KP1_662939224, T7h, KP1_111140466 * T7i); + O[WS(os, 52)] = T7k - T7l; + O[WS(os, 116)] = T7k + T7l; + } + { + E T7c, T7d, T7g, T7j; + T7c = T6y - T6J; + T7d = FMA(KP390180644, T71, KP1_961570560 * T7a); + O[WS(os, 36)] = T7c - T7d; + O[WS(os, 100)] = T7c + T7d; + T7g = T7e - T7f; + T7j = FNMS(KP1_662939224, T7i, KP1_111140466 * T7h); + O[WS(os, 84)] = T7g - T7j; + O[WS(os, 20)] = T7g + T7j; + } + } + { + E T4Y, T5c, T58, T5g, T51, T5d, T55, T5f; + { + E T4W, T4X, T56, T57; + T4W = T2a - T2j; + T4X = FMA(KP765366864, T2t, KP1_847759065 * T2C); + T4Y = T4W - T4X; + T5c = T4W + T4X; + T56 = T48 - T4r; + T57 = T4I - T4z; + T58 = T56 + T57; + T5g = T57 - T56; + } + { + E T4Z, T50, T53, T54; + T4Z = T2N - T36; + T50 = T3j - T3a; + T51 = FNMS(KP1_662939224, T50, KP1_111140466 * T4Z); + T5d = FMA(KP1_662939224, T4Z, KP1_111140466 * T50); + T53 = T3v - T3O; + T54 = T4v - T4u; + T55 = T53 + T54; + T5f = T53 - T54; + } + { + E T52, T59, T5i, T5j; + T52 = T4Y + T51; + T59 = FNMS(KP942793473, T58, KP1_763842528 * T55); + O[WS(os, 74)] = T52 - T59; + O[WS(os, 10)] = T52 + T59; + T5i = T5c + T5d; + T5j = FMA(KP1_913880671, T5f, KP580569354 * T5g); + O[WS(os, 58)] = T5i - T5j; + O[WS(os, 122)] = T5i + T5j; + } + { + E T5a, T5b, T5e, T5h; + T5a = T4Y - T51; + T5b = FMA(KP942793473, T55, KP1_763842528 * T58); + O[WS(os, 42)] = T5a - T5b; + O[WS(os, 106)] = T5a + T5b; + T5e = T5c - T5d; + T5h = FNMS(KP1_913880671, T5g, KP580569354 * T5f); + O[WS(os, 90)] = T5e - T5h; + O[WS(os, 26)] = T5e + T5h; + } + } + { + E T7o, T7C, T7y, T7G, T7r, T7D, T7v, T7F; + { + E T7m, T7n, T7w, T7x; + T7m = T6q + T6r; + T7n = KP1_414213562 * (T6t + T6w); + T7o = T7m - T7n; + T7C = T7m + T7n; + T7w = KP707106781 * (T6U - T6Z); + T7x = T78 - T75; + T7y = T7w + T7x; + T7G = T7x - T7w; + } + { + E T7p, T7q, T7t, T7u; + T7p = T6z - T6C; + T7q = T6H - T6E; + T7r = FNMS(KP1_847759065, T7q, KP765366864 * T7p); + T7D = FMA(KP1_847759065, T7p, KP765366864 * T7q); + T7t = T6L - T6O; + T7u = KP707106781 * (T73 - T72); + T7v = T7t + T7u; + T7F = T7t - T7u; + } + { + E T7s, T7z, T7I, T7J; + T7s = T7o + T7r; + T7z = FNMS(KP1_111140466, T7y, KP1_662939224 * T7v); + O[WS(os, 76)] = T7s - T7z; + O[WS(os, 12)] = T7s + T7z; + T7I = T7C + T7D; + T7J = FMA(KP1_961570560, T7F, KP390180644 * T7G); + O[WS(os, 60)] = T7I - T7J; + O[WS(os, 124)] = T7I + T7J; + } + { + E T7A, T7B, T7E, T7H; + T7A = T7o - T7r; + T7B = FMA(KP1_111140466, T7v, KP1_662939224 * T7y); + O[WS(os, 44)] = T7A - T7B; + O[WS(os, 108)] = T7A + T7B; + T7E = T7C - T7D; + T7H = FNMS(KP1_961570560, T7G, KP390180644 * T7F); + O[WS(os, 92)] = T7E - T7H; + O[WS(os, 28)] = T7E + T7H; + } + } + { + E T5q, T5U, T5Q, T5Y, T5x, T5V, T5J, T5X; + { + E T5m, T5p, T5M, T5P; + T5m = T5k - T5l; + T5p = FNMS(KP1_847759065, T5o, KP765366864 * T5n); + T5q = T5m + T5p; + T5U = T5m - T5p; + T5M = T5K + T5L; + T5P = T5N + T5O; + T5Q = T5M + T5P; + T5Y = T5P - T5M; + } + { + E T5t, T5w, T5B, T5I; + T5t = T5r + T5s; + T5w = T5u + T5v; + T5x = FNMS(KP1_111140466, T5w, KP1_662939224 * T5t); + T5V = FMA(KP1_111140466, T5t, KP1_662939224 * T5w); + T5B = T5z + T5A; + T5I = T5E + T5H; + T5J = T5B + T5I; + T5X = T5B - T5I; + } + { + E T5y, T5R, T60, T61; + T5y = T5q + T5x; + T5R = FNMS(KP580569354, T5Q, KP1_913880671 * T5J); + O[WS(os, 70)] = T5y - T5R; + O[WS(os, 6)] = T5y + T5R; + T60 = T5U + T5V; + T61 = FMA(KP1_763842528, T5X, KP942793473 * T5Y); + O[WS(os, 54)] = T60 - T61; + O[WS(os, 118)] = T60 + T61; + } + { + E T5S, T5T, T5W, T5Z; + T5S = T5q - T5x; + T5T = FMA(KP580569354, T5J, KP1_913880671 * T5Q); + O[WS(os, 38)] = T5S - T5T; + O[WS(os, 102)] = T5S + T5T; + T5W = T5U - T5V; + T5Z = FNMS(KP1_763842528, T5Y, KP942793473 * T5X); + O[WS(os, 86)] = T5W - T5Z; + O[WS(os, 22)] = T5W + T5Z; + } + } + { + E T64, T6i, T6e, T6m, T67, T6j, T6b, T6l; + { + E T62, T63, T6c, T6d; + T62 = T5k + T5l; + T63 = FMA(KP1_847759065, T5n, KP765366864 * T5o); + T64 = T62 - T63; + T6i = T62 + T63; + T6c = T5E - T5H; + T6d = T5O - T5N; + T6e = T6c + T6d; + T6m = T6d - T6c; + } + { + E T65, T66, T69, T6a; + T65 = T5r - T5s; + T66 = T5v - T5u; + T67 = FNMS(KP1_961570560, T66, KP390180644 * T65); + T6j = FMA(KP1_961570560, T65, KP390180644 * T66); + T69 = T5z - T5A; + T6a = T5L - T5K; + T6b = T69 + T6a; + T6l = T69 - T6a; + } + { + E T68, T6f, T6o, T6p; + T68 = T64 + T67; + T6f = FNMS(KP1_268786568, T6e, KP1_546020906 * T6b); + O[WS(os, 78)] = T68 - T6f; + O[WS(os, 14)] = T68 + T6f; + T6o = T6i + T6j; + T6p = FMA(KP1_990369453, T6l, KP196034280 * T6m); + O[WS(os, 62)] = T6o - T6p; + O[WS(os, 126)] = T6o + T6p; + } + { + E T6g, T6h, T6k, T6n; + T6g = T64 - T67; + T6h = FMA(KP1_268786568, T6b, KP1_546020906 * T6e); + O[WS(os, 46)] = T6g - T6h; + O[WS(os, 110)] = T6g + T6h; + T6k = T6i - T6j; + T6n = FNMS(KP1_990369453, T6m, KP196034280 * T6l); + O[WS(os, 94)] = T6k - T6n; + O[WS(os, 30)] = T6k + T6n; + } + } + { + E T8Z, Tb1, T9C, Tb2, Tbe, Tbq, Tbb, Tbp, TaX, Tbs, Tb5, Tbi, TaI, Tbt, Tb4; + E Tbl; + { + E T8F, T8Y, Tb9, Tba; + T8F = T8x + T8E; + T8Y = FNMS(KP390180644, T8X, KP1_961570560 * T8Q); + T8Z = T8F + T8Y; + Tb1 = T8F - T8Y; + { + E T9q, T9B, Tbc, Tbd; + T9q = T9a + T9p; + T9B = T9t + T9A; + T9C = FNMS(KP196034280, T9B, KP1_990369453 * T9q); + Tb2 = FMA(KP196034280, T9q, KP1_990369453 * T9B); + Tbc = T9a - T9p; + Tbd = T9A - T9t; + Tbe = FNMS(KP1_546020906, Tbd, KP1_268786568 * Tbc); + Tbq = FMA(KP1_546020906, Tbc, KP1_268786568 * Tbd); + } + Tb9 = T8x - T8E; + Tba = FMA(KP390180644, T8Q, KP1_961570560 * T8X); + Tbb = Tb9 - Tba; + Tbp = Tb9 + Tba; + { + E TaW, Tbg, TaL, Tbh, TaJ, TaK; + TaW = TaO + TaV; + Tbg = T9O - Ta3; + TaJ = FMA(KP195090322, Taf, KP980785280 * Tam); + TaK = FNMS(KP195090322, Tay, KP980785280 * TaF); + TaL = TaJ + TaK; + Tbh = TaK - TaJ; + TaX = TaL + TaW; + Tbs = Tbg - Tbh; + Tb5 = TaW - TaL; + Tbi = Tbg + Tbh; + } + { + E Ta4, Tbk, TaH, Tbj, Tan, TaG; + Ta4 = T9O + Ta3; + Tbk = TaV - TaO; + Tan = FNMS(KP195090322, Tam, KP980785280 * Taf); + TaG = FMA(KP980785280, Tay, KP195090322 * TaF); + TaH = Tan + TaG; + Tbj = Tan - TaG; + TaI = Ta4 + TaH; + Tbt = Tbk - Tbj; + Tb4 = Ta4 - TaH; + Tbl = Tbj + Tbk; + } + } + { + E T9D, TaY, Tbr, Tbu; + T9D = T8Z + T9C; + TaY = FNMS(KP098135348, TaX, KP1_997590912 * TaI); + O[WS(os, 65)] = T9D - TaY; + O[WS(os, 1)] = T9D + TaY; + Tbr = Tbp - Tbq; + Tbu = FNMS(KP1_883088130, Tbt, KP673779706 * Tbs); + O[WS(os, 89)] = Tbr - Tbu; + O[WS(os, 25)] = Tbr + Tbu; + } + { + E Tbv, Tbw, TaZ, Tb0; + Tbv = Tbp + Tbq; + Tbw = FMA(KP1_883088130, Tbs, KP673779706 * Tbt); + O[WS(os, 57)] = Tbv - Tbw; + O[WS(os, 121)] = Tbv + Tbw; + TaZ = T8Z - T9C; + Tb0 = FMA(KP098135348, TaI, KP1_997590912 * TaX); + O[WS(os, 33)] = TaZ - Tb0; + O[WS(os, 97)] = TaZ + Tb0; + } + { + E Tb3, Tb6, Tbf, Tbm; + Tb3 = Tb1 - Tb2; + Tb6 = FNMS(KP1_481902250, Tb5, KP1_343117909 * Tb4); + O[WS(os, 81)] = Tb3 - Tb6; + O[WS(os, 17)] = Tb3 + Tb6; + Tbf = Tbb + Tbe; + Tbm = FNMS(KP855110186, Tbl, KP1_807978586 * Tbi); + O[WS(os, 73)] = Tbf - Tbm; + O[WS(os, 9)] = Tbf + Tbm; + } + { + E Tbn, Tbo, Tb7, Tb8; + Tbn = Tbb - Tbe; + Tbo = FMA(KP855110186, Tbi, KP1_807978586 * Tbl); + O[WS(os, 41)] = Tbn - Tbo; + O[WS(os, 105)] = Tbn + Tbo; + Tb7 = Tb1 + Tb2; + Tb8 = FMA(KP1_481902250, Tb4, KP1_343117909 * Tb5); + O[WS(os, 49)] = Tb7 - Tb8; + O[WS(os, 113)] = Tb7 + Tb8; + } + } + { + E TcR, TdR, Tda, TdS, Te4, Teg, Te1, Tef, TdN, Tei, TdV, Te8, TdC, Tej, TdU; + E Teb; + { + E TcJ, TcQ, TdZ, Te0; + TcJ = TcF + TcI; + TcQ = FNMS(KP1_111140466, TcP, KP1_662939224 * TcM); + TcR = TcJ + TcQ; + TdR = TcJ - TcQ; + { + E Td2, Td9, Te2, Te3; + Td2 = TcU + Td1; + Td9 = Td5 + Td8; + Tda = FNMS(KP580569354, Td9, KP1_913880671 * Td2); + TdS = FMA(KP580569354, Td2, KP1_913880671 * Td9); + Te2 = TcU - Td1; + Te3 = Td8 - Td5; + Te4 = FNMS(KP1_763842528, Te3, KP942793473 * Te2); + Teg = FMA(KP1_763842528, Te2, KP942793473 * Te3); + } + TdZ = TcF - TcI; + Te0 = FMA(KP1_111140466, TcM, KP1_662939224 * TcP); + Te1 = TdZ - Te0; + Tef = TdZ + Te0; + { + E TdM, Te6, TdF, Te7, TdD, TdE; + TdM = TdI + TdL; + Te6 = Tde - Tdl; + TdD = FMA(KP555570233, Tdp, KP831469612 * Tds); + TdE = FNMS(KP555570233, Tdw, KP831469612 * Tdz); + TdF = TdD + TdE; + Te7 = TdE - TdD; + TdN = TdF + TdM; + Tei = Te6 - Te7; + TdV = TdM - TdF; + Te8 = Te6 + Te7; + } + { + E Tdm, Tea, TdB, Te9, Tdt, TdA; + Tdm = Tde + Tdl; + Tea = TdL - TdI; + Tdt = FNMS(KP555570233, Tds, KP831469612 * Tdp); + TdA = FMA(KP831469612, Tdw, KP555570233 * Tdz); + TdB = Tdt + TdA; + Te9 = Tdt - TdA; + TdC = Tdm + TdB; + Tej = Tea - Te9; + TdU = Tdm - TdB; + Teb = Te9 + Tea; + } + } + { + E Tdb, TdO, Teh, Tek; + Tdb = TcR + Tda; + TdO = FNMS(KP293460948, TdN, KP1_978353019 * TdC); + O[WS(os, 67)] = Tdb - TdO; + O[WS(os, 3)] = Tdb + TdO; + Teh = Tef - Teg; + Tek = FNMS(KP1_940062506, Tej, KP485960359 * Tei); + O[WS(os, 91)] = Teh - Tek; + O[WS(os, 27)] = Teh + Tek; + } + { + E Tel, Tem, TdP, TdQ; + Tel = Tef + Teg; + Tem = FMA(KP1_940062506, Tei, KP485960359 * Tej); + O[WS(os, 59)] = Tel - Tem; + O[WS(os, 123)] = Tel + Tem; + TdP = TcR - Tda; + TdQ = FMA(KP293460948, TdC, KP1_978353019 * TdN); + O[WS(os, 35)] = TdP - TdQ; + O[WS(os, 99)] = TdP + TdQ; + } + { + E TdT, TdW, Te5, Tec; + TdT = TdR - TdS; + TdW = FNMS(KP1_606415062, TdV, KP1_191398608 * TdU); + O[WS(os, 83)] = TdT - TdW; + O[WS(os, 19)] = TdT + TdW; + Te5 = Te1 + Te4; + Tec = FNMS(KP1_028205488, Teb, KP1_715457220 * Te8); + O[WS(os, 75)] = Te5 - Tec; + O[WS(os, 11)] = Te5 + Tec; + } + { + E Ted, Tee, TdX, TdY; + Ted = Te1 - Te4; + Tee = FMA(KP1_028205488, Te8, KP1_715457220 * Teb); + O[WS(os, 43)] = Ted - Tee; + O[WS(os, 107)] = Ted + Tee; + TdX = TdR + TdS; + TdY = FMA(KP1_606415062, TdU, KP1_191398608 * TdV); + O[WS(os, 51)] = TdX - TdY; + O[WS(os, 115)] = TdX + TdY; + } + } + { + E TbD, Tc7, TbK, Tc8, Tck, Tcw, Tch, Tcv, Tc3, Tcy, Tcb, Tco, TbW, Tcz, Tca; + E Tcr; + { + E Tbz, TbC, Tcf, Tcg; + Tbz = Tbx - Tby; + TbC = FNMS(KP1_662939224, TbB, KP1_111140466 * TbA); + TbD = Tbz + TbC; + Tc7 = Tbz - TbC; + { + E TbG, TbJ, Tci, Tcj; + TbG = TbE + TbF; + TbJ = TbH + TbI; + TbK = FNMS(KP942793473, TbJ, KP1_763842528 * TbG); + Tc8 = FMA(KP942793473, TbG, KP1_763842528 * TbJ); + Tci = TbE - TbF; + Tcj = TbI - TbH; + Tck = FNMS(KP1_913880671, Tcj, KP580569354 * Tci); + Tcw = FMA(KP1_913880671, Tci, KP580569354 * Tcj); + } + Tcf = Tbx + Tby; + Tcg = FMA(KP1_662939224, TbA, KP1_111140466 * TbB); + Tch = Tcf - Tcg; + Tcv = Tcf + Tcg; + { + E Tc2, Tcm, TbZ, Tcn, TbX, TbY; + Tc2 = Tc0 + Tc1; + Tcm = TbM - TbN; + TbX = FMA(KP831469612, TbP, KP555570233 * TbQ); + TbY = FNMS(KP831469612, TbS, KP555570233 * TbT); + TbZ = TbX + TbY; + Tcn = TbY - TbX; + Tc3 = TbZ + Tc2; + Tcy = Tcm - Tcn; + Tcb = Tc2 - TbZ; + Tco = Tcm + Tcn; + } + { + E TbO, Tcq, TbV, Tcp, TbR, TbU; + TbO = TbM + TbN; + Tcq = Tc1 - Tc0; + TbR = FNMS(KP831469612, TbQ, KP555570233 * TbP); + TbU = FMA(KP555570233, TbS, KP831469612 * TbT); + TbV = TbR + TbU; + Tcp = TbR - TbU; + TbW = TbO + TbV; + Tcz = Tcq - Tcp; + Tca = TbO - TbV; + Tcr = Tcp + Tcq; + } + } + { + E TbL, Tc4, Tcx, TcA; + TbL = TbD + TbK; + Tc4 = FNMS(KP485960359, Tc3, KP1_940062506 * TbW); + O[WS(os, 69)] = TbL - Tc4; + O[WS(os, 5)] = TbL + Tc4; + Tcx = Tcv - Tcw; + TcA = FNMS(KP1_978353019, Tcz, KP293460948 * Tcy); + O[WS(os, 93)] = Tcx - TcA; + O[WS(os, 29)] = Tcx + TcA; + } + { + E TcB, TcC, Tc5, Tc6; + TcB = Tcv + Tcw; + TcC = FMA(KP1_978353019, Tcy, KP293460948 * Tcz); + O[WS(os, 61)] = TcB - TcC; + O[WS(os, 125)] = TcB + TcC; + Tc5 = TbD - TbK; + Tc6 = FMA(KP485960359, TbW, KP1_940062506 * Tc3); + O[WS(os, 37)] = Tc5 - Tc6; + O[WS(os, 101)] = Tc5 + Tc6; + } + { + E Tc9, Tcc, Tcl, Tcs; + Tc9 = Tc7 - Tc8; + Tcc = FNMS(KP1_715457220, Tcb, KP1_028205488 * Tca); + O[WS(os, 85)] = Tc9 - Tcc; + O[WS(os, 21)] = Tc9 + Tcc; + Tcl = Tch + Tck; + Tcs = FNMS(KP1_191398608, Tcr, KP1_606415062 * Tco); + O[WS(os, 77)] = Tcl - Tcs; + O[WS(os, 13)] = Tcl + Tcs; + } + { + E Tct, Tcu, Tcd, Tce; + Tct = Tch - Tck; + Tcu = FMA(KP1_191398608, Tco, KP1_606415062 * Tcr); + O[WS(os, 45)] = Tct - Tcu; + O[WS(os, 109)] = Tct + Tcu; + Tcd = Tc7 + Tc8; + Tce = FMA(KP1_715457220, Tca, KP1_028205488 * Tcb); + O[WS(os, 53)] = Tcd - Tce; + O[WS(os, 117)] = Tcd + Tce; + } + } + { + E Tet, TeX, TeA, TeY, Tfa, Tfm, Tf7, Tfl, TeT, Tfo, Tf1, Tfe, TeM, Tfp, Tf0; + E Tfh; + { + E Tep, Tes, Tf5, Tf6; + Tep = Ten - Teo; + Tes = FNMS(KP1_961570560, Ter, KP390180644 * Teq); + Tet = Tep + Tes; + TeX = Tep - Tes; + { + E Tew, Tez, Tf8, Tf9; + Tew = Teu - Tev; + Tez = Tex + Tey; + TeA = FNMS(KP1_268786568, Tez, KP1_546020906 * Tew); + TeY = FMA(KP1_268786568, Tew, KP1_546020906 * Tez); + Tf8 = Teu + Tev; + Tf9 = Tey - Tex; + Tfa = FNMS(KP1_990369453, Tf9, KP196034280 * Tf8); + Tfm = FMA(KP1_990369453, Tf8, KP196034280 * Tf9); + } + Tf5 = Ten + Teo; + Tf6 = FMA(KP1_961570560, Teq, KP390180644 * Ter); + Tf7 = Tf5 - Tf6; + Tfl = Tf5 + Tf6; + { + E TeS, Tfc, TeP, Tfd, TeN, TeO; + TeS = TeQ + TeR; + Tfc = TeC + TeD; + TeN = FMA(KP980785280, TeF, KP195090322 * TeG); + TeO = FMA(KP980785280, TeI, KP195090322 * TeJ); + TeP = TeN - TeO; + Tfd = TeN + TeO; + TeT = TeP + TeS; + Tfo = Tfc + Tfd; + Tf1 = TeS - TeP; + Tfe = Tfc - Tfd; + } + { + E TeE, Tfg, TeL, Tff, TeH, TeK; + TeE = TeC - TeD; + Tfg = TeR - TeQ; + TeH = FNMS(KP980785280, TeG, KP195090322 * TeF); + TeK = FNMS(KP980785280, TeJ, KP195090322 * TeI); + TeL = TeH + TeK; + Tff = TeH - TeK; + TeM = TeE + TeL; + Tfp = Tfg - Tff; + Tf0 = TeE - TeL; + Tfh = Tff + Tfg; + } + } + { + E TeB, TeU, Tfn, Tfq; + TeB = Tet + TeA; + TeU = FNMS(KP673779706, TeT, KP1_883088130 * TeM); + O[WS(os, 71)] = TeB - TeU; + O[WS(os, 7)] = TeB + TeU; + Tfn = Tfl - Tfm; + Tfq = FNMS(KP1_997590912, Tfp, KP098135348 * Tfo); + O[WS(os, 95)] = Tfn - Tfq; + O[WS(os, 31)] = Tfn + Tfq; + } + { + E Tfr, Tfs, TeV, TeW; + Tfr = Tfl + Tfm; + Tfs = FMA(KP1_997590912, Tfo, KP098135348 * Tfp); + O[WS(os, 63)] = Tfr - Tfs; + O[WS(os, 127)] = Tfr + Tfs; + TeV = Tet - TeA; + TeW = FMA(KP673779706, TeM, KP1_883088130 * TeT); + O[WS(os, 39)] = TeV - TeW; + O[WS(os, 103)] = TeV + TeW; + } + { + E TeZ, Tf2, Tfb, Tfi; + TeZ = TeX - TeY; + Tf2 = FNMS(KP1_807978586, Tf1, KP855110186 * Tf0); + O[WS(os, 87)] = TeZ - Tf2; + O[WS(os, 23)] = TeZ + Tf2; + Tfb = Tf7 + Tfa; + Tfi = FNMS(KP1_343117909, Tfh, KP1_481902250 * Tfe); + O[WS(os, 79)] = Tfb - Tfi; + O[WS(os, 15)] = Tfb + Tfi; + } + { + E Tfj, Tfk, Tf3, Tf4; + Tfj = Tf7 - Tfa; + Tfk = FMA(KP1_343117909, Tfe, KP1_481902250 * Tfh); + O[WS(os, 47)] = Tfj - Tfk; + O[WS(os, 111)] = Tfj + Tfk; + Tf3 = TeX + TeY; + Tf4 = FMA(KP1_807978586, Tf0, KP855110186 * Tf1); + O[WS(os, 55)] = Tf3 - Tf4; + O[WS(os, 119)] = Tf3 + Tf4; + } + } + } +} + +static void mhc2r_128(const R *ri, const R *ii, R *O, stride ris, stride iis, stride os, int v, int ivs, int ovs) +{ + int i; + for (i = v; i > 0; --i) { + mhc2r_128_0(ri, ii, O, ris, iis, os); + ri += ivs; + ii += ivs; + O += ovs; + } +} + +static const khc2r_desc desc = { 128, "mhc2r_128", {812, 198, 144, 0}, &GENUS, 0, 0, 0, 0, 0 }; + +void X(codelet_mhc2r_128) (planner *p) { + X(khc2r_register) (p, mhc2r_128, &desc); +} diff --git a/src/fftw3/rdft/codelets/hc2r/mhc2r_32.c b/src/fftw3/rdft/codelets/hc2r/mhc2r_32.c new file mode 100644 index 0000000..154a6d4 --- /dev/null +++ b/src/fftw3/rdft/codelets/hc2r/mhc2r_32.c @@ -0,0 +1,346 @@ +/* + * Copyright (c) 2003 Matteo Frigo + * Copyright (c) 2003 Massachusetts Institute of Technology + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +/* This file was automatically generated --- DO NOT EDIT */ +/* Generated on Sat Jul 5 22:11:15 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_hc2r_noinline -compact -variables 4 -sign 1 -n 32 -name mhc2r_32 -include hc2r.h */ + +/* + * This function contains 156 FP additions, 50 FP multiplications, + * (or, 140 additions, 34 multiplications, 16 fused multiply/add), + * 53 stack variables, and 64 memory accesses + */ +/* + * Generator Id's : + * $Id: mhc2r_32.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: mhc2r_32.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: mhc2r_32.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + */ + +#include "hc2r.h" + +static void mhc2r_32_0(const R *ri, const R *ii, R *O, stride ris, stride iis, stride os) +{ + DK(KP1_662939224, +1.662939224605090474157576755235811513477121624); + DK(KP1_111140466, +1.111140466039204449485661627897065748749874382); + DK(KP1_961570560, +1.961570560806460898252364472268478073947867462); + DK(KP390180644, +0.390180644032256535696569736954044481855383236); + DK(KP765366864, +0.765366864730179543456919968060797733522689125); + DK(KP1_847759065, +1.847759065022573512256366378793576573644833252); + DK(KP707106781, +0.707106781186547524400844362104849039284835938); + DK(KP1_414213562, +1.414213562373095048801688724209698078569671875); + DK(KP2_000000000, +2.000000000000000000000000000000000000000000000); + { + E T9, T2c, TB, T1y, T6, T2b, Ty, T1v, Th, T2e, T2f, TD, TK, T1C, T1F; + E T1h, Tp, T2i, T2m, TN, T13, T1K, T1Y, T1k, Tw, TU, T1l, TW, T1V, T2j; + E T1R, T2l; + { + E T7, T8, T1w, Tz, TA, T1x; + T7 = ri[WS(ris, 4)]; + T8 = ri[WS(ris, 12)]; + T1w = T7 - T8; + Tz = ii[WS(iis, 4)]; + TA = ii[WS(iis, 12)]; + T1x = Tz + TA; + T9 = KP2_000000000 * (T7 + T8); + T2c = KP1_414213562 * (T1w + T1x); + TB = KP2_000000000 * (Tz - TA); + T1y = KP1_414213562 * (T1w - T1x); + } + { + E T5, T1u, T3, T1s; + { + E T4, T1t, T1, T2; + T4 = ri[WS(ris, 8)]; + T5 = KP2_000000000 * T4; + T1t = ii[WS(iis, 8)]; + T1u = KP2_000000000 * T1t; + T1 = ri[0]; + T2 = ri[WS(ris, 16)]; + T3 = T1 + T2; + T1s = T1 - T2; + } + T6 = T3 + T5; + T2b = T1s + T1u; + Ty = T3 - T5; + T1v = T1s - T1u; + } + { + E Td, T1A, TG, T1E, Tg, T1D, TJ, T1B; + { + E Tb, Tc, TE, TF; + Tb = ri[WS(ris, 2)]; + Tc = ri[WS(ris, 14)]; + Td = Tb + Tc; + T1A = Tb - Tc; + TE = ii[WS(iis, 2)]; + TF = ii[WS(iis, 14)]; + TG = TE - TF; + T1E = TE + TF; + } + { + E Te, Tf, TH, TI; + Te = ri[WS(ris, 10)]; + Tf = ri[WS(ris, 6)]; + Tg = Te + Tf; + T1D = Te - Tf; + TH = ii[WS(iis, 10)]; + TI = ii[WS(iis, 6)]; + TJ = TH - TI; + T1B = TH + TI; + } + Th = KP2_000000000 * (Td + Tg); + T2e = T1A + T1B; + T2f = T1E - T1D; + TD = Td - Tg; + TK = TG - TJ; + T1C = T1A - T1B; + T1F = T1D + T1E; + T1h = KP2_000000000 * (TJ + TG); + } + { + E Tl, T1I, TZ, T1X, To, T1W, T12, T1J; + { + E Tj, Tk, TX, TY; + Tj = ri[WS(ris, 1)]; + Tk = ri[WS(ris, 15)]; + Tl = Tj + Tk; + T1I = Tj - Tk; + TX = ii[WS(iis, 1)]; + TY = ii[WS(iis, 15)]; + TZ = TX - TY; + T1X = TX + TY; + } + { + E Tm, Tn, T10, T11; + Tm = ri[WS(ris, 9)]; + Tn = ri[WS(ris, 7)]; + To = Tm + Tn; + T1W = Tm - Tn; + T10 = ii[WS(iis, 9)]; + T11 = ii[WS(iis, 7)]; + T12 = T10 - T11; + T1J = T10 + T11; + } + Tp = Tl + To; + T2i = T1I + T1J; + T2m = T1X - T1W; + TN = Tl - To; + T13 = TZ - T12; + T1K = T1I - T1J; + T1Y = T1W + T1X; + T1k = T12 + TZ; + } + { + E Ts, T1L, TT, T1M, Tv, T1O, TQ, T1P; + { + E Tq, Tr, TR, TS; + Tq = ri[WS(ris, 5)]; + Tr = ri[WS(ris, 11)]; + Ts = Tq + Tr; + T1L = Tq - Tr; + TR = ii[WS(iis, 5)]; + TS = ii[WS(iis, 11)]; + TT = TR - TS; + T1M = TR + TS; + } + { + E Tt, Tu, TO, TP; + Tt = ri[WS(ris, 3)]; + Tu = ri[WS(ris, 13)]; + Tv = Tt + Tu; + T1O = Tt - Tu; + TO = ii[WS(iis, 13)]; + TP = ii[WS(iis, 3)]; + TQ = TO - TP; + T1P = TP + TO; + } + Tw = Ts + Tv; + TU = TQ - TT; + T1l = TT + TQ; + TW = Ts - Tv; + { + E T1T, T1U, T1N, T1Q; + T1T = T1L + T1M; + T1U = T1O + T1P; + T1V = KP707106781 * (T1T - T1U); + T2j = KP707106781 * (T1T + T1U); + T1N = T1L - T1M; + T1Q = T1O - T1P; + T1R = KP707106781 * (T1N + T1Q); + T2l = KP707106781 * (T1N - T1Q); + } + } + { + E Tx, T1r, Ti, T1q, Ta; + Tx = KP2_000000000 * (Tp + Tw); + T1r = KP2_000000000 * (T1l + T1k); + Ta = T6 + T9; + Ti = Ta + Th; + T1q = Ta - Th; + O[WS(os, 16)] = Ti - Tx; + O[WS(os, 24)] = T1q + T1r; + O[0] = Ti + Tx; + O[WS(os, 8)] = T1q - T1r; + } + { + E T1i, T1o, T1n, T1p, T1g, T1j, T1m; + T1g = T6 - T9; + T1i = T1g - T1h; + T1o = T1g + T1h; + T1j = Tp - Tw; + T1m = T1k - T1l; + T1n = KP1_414213562 * (T1j - T1m); + T1p = KP1_414213562 * (T1j + T1m); + O[WS(os, 20)] = T1i - T1n; + O[WS(os, 28)] = T1o + T1p; + O[WS(os, 4)] = T1i + T1n; + O[WS(os, 12)] = T1o - T1p; + } + { + E TM, T16, T15, T17; + { + E TC, TL, TV, T14; + TC = Ty - TB; + TL = KP1_414213562 * (TD - TK); + TM = TC + TL; + T16 = TC - TL; + TV = TN + TU; + T14 = TW + T13; + T15 = FNMS(KP765366864, T14, KP1_847759065 * TV); + T17 = FMA(KP765366864, TV, KP1_847759065 * T14); + } + O[WS(os, 18)] = TM - T15; + O[WS(os, 26)] = T16 + T17; + O[WS(os, 2)] = TM + T15; + O[WS(os, 10)] = T16 - T17; + } + { + E T2t, T2x, T2w, T2y; + { + E T2r, T2s, T2u, T2v; + T2r = T2b + T2c; + T2s = FMA(KP1_847759065, T2e, KP765366864 * T2f); + T2t = T2r - T2s; + T2x = T2r + T2s; + T2u = T2i + T2j; + T2v = T2m - T2l; + T2w = FNMS(KP1_961570560, T2v, KP390180644 * T2u); + T2y = FMA(KP1_961570560, T2u, KP390180644 * T2v); + } + O[WS(os, 23)] = T2t - T2w; + O[WS(os, 31)] = T2x + T2y; + O[WS(os, 7)] = T2t + T2w; + O[WS(os, 15)] = T2x - T2y; + } + { + E T1a, T1e, T1d, T1f; + { + E T18, T19, T1b, T1c; + T18 = Ty + TB; + T19 = KP1_414213562 * (TD + TK); + T1a = T18 - T19; + T1e = T18 + T19; + T1b = TN - TU; + T1c = T13 - TW; + T1d = FNMS(KP1_847759065, T1c, KP765366864 * T1b); + T1f = FMA(KP1_847759065, T1b, KP765366864 * T1c); + } + O[WS(os, 22)] = T1a - T1d; + O[WS(os, 30)] = T1e + T1f; + O[WS(os, 6)] = T1a + T1d; + O[WS(os, 14)] = T1e - T1f; + } + { + E T25, T29, T28, T2a; + { + E T23, T24, T26, T27; + T23 = T1v - T1y; + T24 = FMA(KP765366864, T1C, KP1_847759065 * T1F); + T25 = T23 - T24; + T29 = T23 + T24; + T26 = T1K - T1R; + T27 = T1Y - T1V; + T28 = FNMS(KP1_662939224, T27, KP1_111140466 * T26); + T2a = FMA(KP1_662939224, T26, KP1_111140466 * T27); + } + O[WS(os, 21)] = T25 - T28; + O[WS(os, 29)] = T29 + T2a; + O[WS(os, 5)] = T25 + T28; + O[WS(os, 13)] = T29 - T2a; + } + { + E T2h, T2p, T2o, T2q; + { + E T2d, T2g, T2k, T2n; + T2d = T2b - T2c; + T2g = FNMS(KP1_847759065, T2f, KP765366864 * T2e); + T2h = T2d + T2g; + T2p = T2d - T2g; + T2k = T2i - T2j; + T2n = T2l + T2m; + T2o = FNMS(KP1_111140466, T2n, KP1_662939224 * T2k); + T2q = FMA(KP1_111140466, T2k, KP1_662939224 * T2n); + } + O[WS(os, 19)] = T2h - T2o; + O[WS(os, 27)] = T2p + T2q; + O[WS(os, 3)] = T2h + T2o; + O[WS(os, 11)] = T2p - T2q; + } + { + E T1H, T21, T20, T22; + { + E T1z, T1G, T1S, T1Z; + T1z = T1v + T1y; + T1G = FNMS(KP765366864, T1F, KP1_847759065 * T1C); + T1H = T1z + T1G; + T21 = T1z - T1G; + T1S = T1K + T1R; + T1Z = T1V + T1Y; + T20 = FNMS(KP390180644, T1Z, KP1_961570560 * T1S); + T22 = FMA(KP390180644, T1S, KP1_961570560 * T1Z); + } + O[WS(os, 17)] = T1H - T20; + O[WS(os, 25)] = T21 + T22; + O[WS(os, 1)] = T1H + T20; + O[WS(os, 9)] = T21 - T22; + } + } +} + +static void mhc2r_32(const R *ri, const R *ii, R *O, stride ris, stride iis, stride os, int v, int ivs, int ovs) +{ + int i; + for (i = v; i > 0; --i) { + mhc2r_32_0(ri, ii, O, ris, iis, os); + ri += ivs; + ii += ivs; + O += ovs; + } +} + +static const khc2r_desc desc = { 32, "mhc2r_32", {140, 34, 16, 0}, &GENUS, 0, 0, 0, 0, 0 }; + +void X(codelet_mhc2r_32) (planner *p) { + X(khc2r_register) (p, mhc2r_32, &desc); +} diff --git a/src/fftw3/rdft/codelets/hc2r/mhc2r_64.c b/src/fftw3/rdft/codelets/hc2r/mhc2r_64.c new file mode 100644 index 0000000..48fb66f --- /dev/null +++ b/src/fftw3/rdft/codelets/hc2r/mhc2r_64.c @@ -0,0 +1,733 @@ +/* + * Copyright (c) 2003 Matteo Frigo + * Copyright (c) 2003 Massachusetts Institute of Technology + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +/* This file was automatically generated --- DO NOT EDIT */ +/* Generated on Sat Jul 5 22:11:18 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_hc2r_noinline -compact -variables 4 -sign 1 -n 64 -name mhc2r_64 -include hc2r.h */ + +/* + * This function contains 394 FP additions, 134 FP multiplications, + * (or, 342 additions, 82 multiplications, 52 fused multiply/add), + * 109 stack variables, and 128 memory accesses + */ +/* + * Generator Id's : + * $Id: mhc2r_64.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: mhc2r_64.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + * $Id: mhc2r_64.c,v 1.1 2008/10/17 06:12:08 scuri Exp $ + */ + +#include "hc2r.h" + +static void mhc2r_64_0(const R *ri, const R *ii, R *O, stride ris, stride iis, stride os) +{ + DK(KP1_268786568, +1.268786568327290996430343226450986741351374190); + DK(KP1_546020906, +1.546020906725473921621813219516939601942082586); + DK(KP196034280, +0.196034280659121203988391127777283691722273346); + DK(KP1_990369453, +1.990369453344393772489673906218959843150949737); + DK(KP942793473, +0.942793473651995297112775251810508755314920638); + DK(KP1_763842528, +1.763842528696710059425513727320776699016885241); + DK(KP580569354, +0.580569354508924735272384751634790549382952557); + DK(KP1_913880671, +1.913880671464417729871595773960539938965698411); + DK(KP1_111140466, +1.111140466039204449485661627897065748749874382); + DK(KP1_662939224, +1.662939224605090474157576755235811513477121624); + DK(KP390180644, +0.390180644032256535696569736954044481855383236); + DK(KP1_961570560, +1.961570560806460898252364472268478073947867462); + DK(KP923879532, +0.923879532511286756128183189396788286822416626); + DK(KP382683432, +0.382683432365089771728459984030398866761344562); + DK(KP707106781, +0.707106781186547524400844362104849039284835938); + DK(KP765366864, +0.765366864730179543456919968060797733522689125); + DK(KP1_847759065, +1.847759065022573512256366378793576573644833252); + DK(KP1_414213562, +1.414213562373095048801688724209698078569671875); + DK(KP2_000000000, +2.000000000000000000000000000000000000000000000); + { + E Ta, T2S, T18, T2u, T3F, T4V, T5l, T61, Th, T2T, T1h, T2v, T3M, T4W, T5o; + E T62, T3Q, T5q, T5u, T44, Tp, Tw, T2V, T2W, T2X, T2Y, T3X, T5t, T1r, T2x; + E T41, T5r, T1A, T2y, T4a, T5y, T5N, T4H, TN, T31, T4E, T5z, T39, T3q, T1L; + E T2B, T4h, T5M, T2h, T2F, T12, T36, T5D, T5J, T5G, T5K, T1U, T26, T23, T27; + E T4p, T4z, T4w, T4A, T34, T3r; + { + E T5, T3A, T3, T3y, T9, T3C, T17, T3D, T6, T14; + { + E T4, T3z, T1, T2; + T4 = ri[WS(ris, 16)]; + T5 = KP2_000000000 * T4; + T3z = ii[WS(iis, 16)]; + T3A = KP2_000000000 * T3z; + T1 = ri[0]; + T2 = ri[WS(ris, 32)]; + T3 = T1 + T2; + T3y = T1 - T2; + { + E T7, T8, T15, T16; + T7 = ri[WS(ris, 8)]; + T8 = ri[WS(ris, 24)]; + T9 = KP2_000000000 * (T7 + T8); + T3C = T7 - T8; + T15 = ii[WS(iis, 8)]; + T16 = ii[WS(iis, 24)]; + T17 = KP2_000000000 * (T15 - T16); + T3D = T15 + T16; + } + } + T6 = T3 + T5; + Ta = T6 + T9; + T2S = T6 - T9; + T14 = T3 - T5; + T18 = T14 - T17; + T2u = T14 + T17; + { + E T3B, T3E, T5j, T5k; + T3B = T3y - T3A; + T3E = KP1_414213562 * (T3C - T3D); + T3F = T3B + T3E; + T4V = T3B - T3E; + T5j = T3y + T3A; + T5k = KP1_414213562 * (T3C + T3D); + T5l = T5j - T5k; + T61 = T5j + T5k; + } + } + { + E Td, T3G, T1c, T3K, Tg, T3J, T1f, T3H, T19, T1g; + { + E Tb, Tc, T1a, T1b; + Tb = ri[WS(ris, 4)]; + Tc = ri[WS(ris, 28)]; + Td = Tb + Tc; + T3G = Tb - Tc; + T1a = ii[WS(iis, 4)]; + T1b = ii[WS(iis, 28)]; + T1c = T1a - T1b; + T3K = T1a + T1b; + } + { + E Te, Tf, T1d, T1e; + Te = ri[WS(ris, 20)]; + Tf = ri[WS(ris, 12)]; + Tg = Te + Tf; + T3J = Te - Tf; + T1d = ii[WS(iis, 20)]; + T1e = ii[WS(iis, 12)]; + T1f = T1d - T1e; + T3H = T1d + T1e; + } + Th = KP2_000000000 * (Td + Tg); + T2T = KP2_000000000 * (T1f + T1c); + T19 = Td - Tg; + T1g = T1c - T1f; + T1h = KP1_414213562 * (T19 - T1g); + T2v = KP1_414213562 * (T19 + T1g); + { + E T3I, T3L, T5m, T5n; + T3I = T3G - T3H; + T3L = T3J + T3K; + T3M = FNMS(KP765366864, T3L, KP1_847759065 * T3I); + T4W = FMA(KP765366864, T3I, KP1_847759065 * T3L); + T5m = T3G + T3H; + T5n = T3K - T3J; + T5o = FNMS(KP1_847759065, T5n, KP765366864 * T5m); + T62 = FMA(KP1_847759065, T5m, KP765366864 * T5n); + } + } + { + E Tl, T3O, T1v, T43, To, T42, T1y, T3P, Ts, T3R, T1p, T3S, Tv, T3U, T1m; + E T3V; + { + E Tj, Tk, T1t, T1u; + Tj = ri[WS(ris, 2)]; + Tk = ri[WS(ris, 30)]; + Tl = Tj + Tk; + T3O = Tj - Tk; + T1t = ii[WS(iis, 2)]; + T1u = ii[WS(iis, 30)]; + T1v = T1t - T1u; + T43 = T1t + T1u; + } + { + E Tm, Tn, T1w, T1x; + Tm = ri[WS(ris, 18)]; + Tn = ri[WS(ris, 14)]; + To = Tm + Tn; + T42 = Tm - Tn; + T1w = ii[WS(iis, 18)]; + T1x = ii[WS(iis, 14)]; + T1y = T1w - T1x; + T3P = T1w + T1x; + } + { + E Tq, Tr, T1n, T1o; + Tq = ri[WS(ris, 10)]; + Tr = ri[WS(ris, 22)]; + Ts = Tq + Tr; + T3R = Tq - Tr; + T1n = ii[WS(iis, 10)]; + T1o = ii[WS(iis, 22)]; + T1p = T1n - T1o; + T3S = T1n + T1o; + } + { + E Tt, Tu, T1k, T1l; + Tt = ri[WS(ris, 6)]; + Tu = ri[WS(ris, 26)]; + Tv = Tt + Tu; + T3U = Tt - Tu; + T1k = ii[WS(iis, 26)]; + T1l = ii[WS(iis, 6)]; + T1m = T1k - T1l; + T3V = T1l + T1k; + } + T3Q = T3O - T3P; + T5q = T3O + T3P; + T5u = T43 - T42; + T44 = T42 + T43; + Tp = Tl + To; + Tw = Ts + Tv; + T2V = Tp - Tw; + { + E T3T, T3W, T1j, T1q; + T2W = T1y + T1v; + T2X = T1p + T1m; + T2Y = T2W - T2X; + T3T = T3R - T3S; + T3W = T3U - T3V; + T3X = KP707106781 * (T3T + T3W); + T5t = KP707106781 * (T3T - T3W); + T1j = Tl - To; + T1q = T1m - T1p; + T1r = T1j + T1q; + T2x = T1j - T1q; + { + E T3Z, T40, T1s, T1z; + T3Z = T3R + T3S; + T40 = T3U + T3V; + T41 = KP707106781 * (T3Z - T40); + T5r = KP707106781 * (T3Z + T40); + T1s = Ts - Tv; + T1z = T1v - T1y; + T1A = T1s + T1z; + T2y = T1z - T1s; + } + } + } + { + E TB, T48, T2c, T4G, TE, T4F, T2f, T49, TI, T4b, T1J, T4c, TL, T4e, T1G; + E T4f; + { + E Tz, TA, T2a, T2b; + Tz = ri[WS(ris, 1)]; + TA = ri[WS(ris, 31)]; + TB = Tz + TA; + T48 = Tz - TA; + T2a = ii[WS(iis, 1)]; + T2b = ii[WS(iis, 31)]; + T2c = T2a - T2b; + T4G = T2a + T2b; + } + { + E TC, TD, T2d, T2e; + TC = ri[WS(ris, 17)]; + TD = ri[WS(ris, 15)]; + TE = TC + TD; + T4F = TC - TD; + T2d = ii[WS(iis, 17)]; + T2e = ii[WS(iis, 15)]; + T2f = T2d - T2e; + T49 = T2d + T2e; + } + { + E TG, TH, T1H, T1I; + TG = ri[WS(ris, 9)]; + TH = ri[WS(ris, 23)]; + TI = TG + TH; + T4b = TG - TH; + T1H = ii[WS(iis, 9)]; + T1I = ii[WS(iis, 23)]; + T1J = T1H - T1I; + T4c = T1H + T1I; + } + { + E TJ, TK, T1E, T1F; + TJ = ri[WS(ris, 7)]; + TK = ri[WS(ris, 25)]; + TL = TJ + TK; + T4e = TJ - TK; + T1E = ii[WS(iis, 25)]; + T1F = ii[WS(iis, 7)]; + T1G = T1E - T1F; + T4f = T1F + T1E; + } + { + E TF, TM, T1D, T1K; + T4a = T48 - T49; + T5y = T48 + T49; + T5N = T4G - T4F; + T4H = T4F + T4G; + TF = TB + TE; + TM = TI + TL; + TN = TF + TM; + T31 = TF - TM; + { + E T4C, T4D, T37, T38; + T4C = T4b + T4c; + T4D = T4e + T4f; + T4E = KP707106781 * (T4C - T4D); + T5z = KP707106781 * (T4C + T4D); + T37 = T2f + T2c; + T38 = T1J + T1G; + T39 = T37 - T38; + T3q = T38 + T37; + } + T1D = TB - TE; + T1K = T1G - T1J; + T1L = T1D + T1K; + T2B = T1D - T1K; + { + E T4d, T4g, T29, T2g; + T4d = T4b - T4c; + T4g = T4e - T4f; + T4h = KP707106781 * (T4d + T4g); + T5M = KP707106781 * (T4d - T4g); + T29 = TI - TL; + T2g = T2c - T2f; + T2h = T29 + T2g; + T2F = T2g - T29; + } + } + } + { + E TQ, T4j, T1P, T4n, TT, T4m, T1S, T4k, TX, T4q, T1Y, T4u, T10, T4t, T21; + E T4r; + { + E TO, TP, T1N, T1O; + TO = ri[WS(ris, 5)]; + TP = ri[WS(ris, 27)]; + TQ = TO + TP; + T4j = TO - TP; + T1N = ii[WS(iis, 5)]; + T1O = ii[WS(iis, 27)]; + T1P = T1N - T1O; + T4n = T1N + T1O; + } + { + E TR, TS, T1Q, T1R; + TR = ri[WS(ris, 21)]; + TS = ri[WS(ris, 11)]; + TT = TR + TS; + T4m = TR - TS; + T1Q = ii[WS(iis, 21)]; + T1R = ii[WS(iis, 11)]; + T1S = T1Q - T1R; + T4k = T1Q + T1R; + } + { + E TV, TW, T1W, T1X; + TV = ri[WS(ris, 3)]; + TW = ri[WS(ris, 29)]; + TX = TV + TW; + T4q = TV - TW; + T1W = ii[WS(iis, 29)]; + T1X = ii[WS(iis, 3)]; + T1Y = T1W - T1X; + T4u = T1X + T1W; + } + { + E TY, TZ, T1Z, T20; + TY = ri[WS(ris, 13)]; + TZ = ri[WS(ris, 19)]; + T10 = TY + TZ; + T4t = TY - TZ; + T1Z = ii[WS(iis, 13)]; + T20 = ii[WS(iis, 19)]; + T21 = T1Z - T20; + T4r = T1Z + T20; + } + { + E TU, T11, T5B, T5C; + TU = TQ + TT; + T11 = TX + T10; + T12 = TU + T11; + T36 = TU - T11; + T5B = T4j + T4k; + T5C = T4n - T4m; + T5D = FNMS(KP923879532, T5C, KP382683432 * T5B); + T5J = FMA(KP923879532, T5B, KP382683432 * T5C); + } + { + E T5E, T5F, T1M, T1T; + T5E = T4q + T4r; + T5F = T4t + T4u; + T5G = FNMS(KP923879532, T5F, KP382683432 * T5E); + T5K = FMA(KP923879532, T5E, KP382683432 * T5F); + T1M = TQ - TT; + T1T = T1P - T1S; + T1U = T1M - T1T; + T26 = T1M + T1T; + } + { + E T1V, T22, T4l, T4o; + T1V = TX - T10; + T22 = T1Y - T21; + T23 = T1V + T22; + T27 = T22 - T1V; + T4l = T4j - T4k; + T4o = T4m + T4n; + T4p = FNMS(KP382683432, T4o, KP923879532 * T4l); + T4z = FMA(KP382683432, T4l, KP923879532 * T4o); + } + { + E T4s, T4v, T32, T33; + T4s = T4q - T4r; + T4v = T4t - T4u; + T4w = FMA(KP923879532, T4s, KP382683432 * T4v); + T4A = FNMS(KP382683432, T4s, KP923879532 * T4v); + T32 = T21 + T1Y; + T33 = T1S + T1P; + T34 = T32 - T33; + T3r = T33 + T32; + } + } + { + E T13, T3x, Ty, T3w, Ti, Tx; + T13 = KP2_000000000 * (TN + T12); + T3x = KP2_000000000 * (T3r + T3q); + Ti = Ta + Th; + Tx = KP2_000000000 * (Tp + Tw); + Ty = Ti + Tx; + T3w = Ti - Tx; + O[WS(os, 32)] = Ty - T13; + O[WS(os, 48)] = T3w + T3x; + O[0] = Ty + T13; + O[WS(os, 16)] = T3w - T3x; + } + { + E T3g, T3k, T3j, T3l; + { + E T3e, T3f, T3h, T3i; + T3e = T2S + T2T; + T3f = KP1_414213562 * (T2V + T2Y); + T3g = T3e - T3f; + T3k = T3e + T3f; + T3h = T31 - T34; + T3i = T39 - T36; + T3j = FNMS(KP1_847759065, T3i, KP765366864 * T3h); + T3l = FMA(KP1_847759065, T3h, KP765366864 * T3i); + } + O[WS(os, 44)] = T3g - T3j; + O[WS(os, 60)] = T3k + T3l; + O[WS(os, 12)] = T3g + T3j; + O[WS(os, 28)] = T3k - T3l; + } + { + E T3o, T3u, T3t, T3v; + { + E T3m, T3n, T3p, T3s; + T3m = Ta - Th; + T3n = KP2_000000000 * (T2X + T2W); + T3o = T3m - T3n; + T3u = T3m + T3n; + T3p = TN - T12; + T3s = T3q - T3r; + T3t = KP1_414213562 * (T3p - T3s); + T3v = KP1_414213562 * (T3p + T3s); + } + O[WS(os, 40)] = T3o - T3t; + O[WS(os, 56)] = T3u + T3v; + O[WS(os, 8)] = T3o + T3t; + O[WS(os, 24)] = T3u - T3v; + } + { + E T30, T3c, T3b, T3d; + { + E T2U, T2Z, T35, T3a; + T2U = T2S - T2T; + T2Z = KP1_414213562 * (T2V - T2Y); + T30 = T2U + T2Z; + T3c = T2U - T2Z; + T35 = T31 + T34; + T3a = T36 + T39; + T3b = FNMS(KP765366864, T3a, KP1_847759065 * T35); + T3d = FMA(KP765366864, T35, KP1_847759065 * T3a); + } + O[WS(os, 36)] = T30 - T3b; + O[WS(os, 52)] = T3c + T3d; + O[WS(os, 4)] = T30 + T3b; + O[WS(os, 20)] = T3c - T3d; + } + { + E T25, T2p, T2i, T2q, T1C, T2k, T2o, T2s, T24, T28; + T24 = KP707106781 * (T1U + T23); + T25 = T1L + T24; + T2p = T1L - T24; + T28 = KP707106781 * (T26 + T27); + T2i = T28 + T2h; + T2q = T2h - T28; + { + E T1i, T1B, T2m, T2n; + T1i = T18 + T1h; + T1B = FNMS(KP765366864, T1A, KP1_847759065 * T1r); + T1C = T1i + T1B; + T2k = T1i - T1B; + T2m = T18 - T1h; + T2n = FMA(KP765366864, T1r, KP1_847759065 * T1A); + T2o = T2m - T2n; + T2s = T2m + T2n; + } + { + E T2j, T2t, T2l, T2r; + T2j = FNMS(KP390180644, T2i, KP1_961570560 * T25); + O[WS(os, 34)] = T1C - T2j; + O[WS(os, 2)] = T1C + T2j; + T2t = FMA(KP1_662939224, T2p, KP1_111140466 * T2q); + O[WS(os, 26)] = T2s - T2t; + O[WS(os, 58)] = T2s + T2t; + T2l = FMA(KP390180644, T25, KP1_961570560 * T2i); + O[WS(os, 18)] = T2k - T2l; + O[WS(os, 50)] = T2k + T2l; + T2r = FNMS(KP1_662939224, T2q, KP1_111140466 * T2p); + O[WS(os, 42)] = T2o - T2r; + O[WS(os, 10)] = T2o + T2r; + } + } + { + E T2D, T2N, T2G, T2O, T2A, T2I, T2M, T2Q, T2C, T2E; + T2C = KP707106781 * (T27 - T26); + T2D = T2B + T2C; + T2N = T2B - T2C; + T2E = KP707106781 * (T1U - T23); + T2G = T2E + T2F; + T2O = T2F - T2E; + { + E T2w, T2z, T2K, T2L; + T2w = T2u - T2v; + T2z = FNMS(KP1_847759065, T2y, KP765366864 * T2x); + T2A = T2w + T2z; + T2I = T2w - T2z; + T2K = T2u + T2v; + T2L = FMA(KP1_847759065, T2x, KP765366864 * T2y); + T2M = T2K - T2L; + T2Q = T2K + T2L; + } + { + E T2H, T2R, T2J, T2P; + T2H = FNMS(KP1_111140466, T2G, KP1_662939224 * T2D); + O[WS(os, 38)] = T2A - T2H; + O[WS(os, 6)] = T2A + T2H; + T2R = FMA(KP1_961570560, T2N, KP390180644 * T2O); + O[WS(os, 30)] = T2Q - T2R; + O[WS(os, 62)] = T2Q + T2R; + T2J = FMA(KP1_111140466, T2D, KP1_662939224 * T2G); + O[WS(os, 22)] = T2I - T2J; + O[WS(os, 54)] = T2I + T2J; + T2P = FNMS(KP1_961570560, T2O, KP390180644 * T2N); + O[WS(os, 46)] = T2M - T2P; + O[WS(os, 14)] = T2M + T2P; + } + } + { + E T5p, T5T, T5w, T5U, T5I, T5W, T5P, T5X, T5s, T5v; + T5p = T5l + T5o; + T5T = T5l - T5o; + T5s = T5q - T5r; + T5v = T5t + T5u; + T5w = FNMS(KP1_111140466, T5v, KP1_662939224 * T5s); + T5U = FMA(KP1_111140466, T5s, KP1_662939224 * T5v); + { + E T5A, T5H, T5L, T5O; + T5A = T5y - T5z; + T5H = T5D + T5G; + T5I = T5A + T5H; + T5W = T5A - T5H; + T5L = T5J - T5K; + T5O = T5M + T5N; + T5P = T5L + T5O; + T5X = T5O - T5L; + } + { + E T5x, T5Q, T5Z, T60; + T5x = T5p + T5w; + T5Q = FNMS(KP580569354, T5P, KP1_913880671 * T5I); + O[WS(os, 35)] = T5x - T5Q; + O[WS(os, 3)] = T5x + T5Q; + T5Z = T5T + T5U; + T60 = FMA(KP1_763842528, T5W, KP942793473 * T5X); + O[WS(os, 27)] = T5Z - T60; + O[WS(os, 59)] = T5Z + T60; + } + { + E T5R, T5S, T5V, T5Y; + T5R = T5p - T5w; + T5S = FMA(KP580569354, T5I, KP1_913880671 * T5P); + O[WS(os, 19)] = T5R - T5S; + O[WS(os, 51)] = T5R + T5S; + T5V = T5T - T5U; + T5Y = FNMS(KP1_763842528, T5X, KP942793473 * T5W); + O[WS(os, 43)] = T5V - T5Y; + O[WS(os, 11)] = T5V + T5Y; + } + } + { + E T3N, T4N, T46, T4O, T4y, T4Q, T4J, T4R, T3Y, T45; + T3N = T3F + T3M; + T4N = T3F - T3M; + T3Y = T3Q + T3X; + T45 = T41 + T44; + T46 = FNMS(KP390180644, T45, KP1_961570560 * T3Y); + T4O = FMA(KP390180644, T3Y, KP1_961570560 * T45); + { + E T4i, T4x, T4B, T4I; + T4i = T4a + T4h; + T4x = T4p + T4w; + T4y = T4i + T4x; + T4Q = T4i - T4x; + T4B = T4z + T4A; + T4I = T4E + T4H; + T4J = T4B + T4I; + T4R = T4I - T4B; + } + { + E T47, T4K, T4T, T4U; + T47 = T3N + T46; + T4K = FNMS(KP196034280, T4J, KP1_990369453 * T4y); + O[WS(os, 33)] = T47 - T4K; + O[WS(os, 1)] = T47 + T4K; + T4T = T4N + T4O; + T4U = FMA(KP1_546020906, T4Q, KP1_268786568 * T4R); + O[WS(os, 25)] = T4T - T4U; + O[WS(os, 57)] = T4T + T4U; + } + { + E T4L, T4M, T4P, T4S; + T4L = T3N - T46; + T4M = FMA(KP196034280, T4y, KP1_990369453 * T4J); + O[WS(os, 17)] = T4L - T4M; + O[WS(os, 49)] = T4L + T4M; + T4P = T4N - T4O; + T4S = FNMS(KP1_546020906, T4R, KP1_268786568 * T4Q); + O[WS(os, 41)] = T4P - T4S; + O[WS(os, 9)] = T4P + T4S; + } + } + { + E T63, T6h, T66, T6i, T6a, T6k, T6d, T6l, T64, T65; + T63 = T61 - T62; + T6h = T61 + T62; + T64 = T5q + T5r; + T65 = T5u - T5t; + T66 = FNMS(KP1_961570560, T65, KP390180644 * T64); + T6i = FMA(KP1_961570560, T64, KP390180644 * T65); + { + E T68, T69, T6b, T6c; + T68 = T5y + T5z; + T69 = T5J + T5K; + T6a = T68 - T69; + T6k = T68 + T69; + T6b = T5D - T5G; + T6c = T5N - T5M; + T6d = T6b + T6c; + T6l = T6c - T6b; + } + { + E T67, T6e, T6n, T6o; + T67 = T63 + T66; + T6e = FNMS(KP1_268786568, T6d, KP1_546020906 * T6a); + O[WS(os, 39)] = T67 - T6e; + O[WS(os, 7)] = T67 + T6e; + T6n = T6h + T6i; + T6o = FMA(KP1_990369453, T6k, KP196034280 * T6l); + O[WS(os, 31)] = T6n - T6o; + O[WS(os, 63)] = T6n + T6o; + } + { + E T6f, T6g, T6j, T6m; + T6f = T63 - T66; + T6g = FMA(KP1_268786568, T6a, KP1_546020906 * T6d); + O[WS(os, 23)] = T6f - T6g; + O[WS(os, 55)] = T6f + T6g; + T6j = T6h - T6i; + T6m = FNMS(KP1_990369453, T6l, KP196034280 * T6k); + O[WS(os, 47)] = T6j - T6m; + O[WS(os, 15)] = T6j + T6m; + } + } + { + E T4X, T5b, T50, T5c, T54, T5e, T57, T5f, T4Y, T4Z; + T4X = T4V - T4W; + T5b = T4V + T4W; + T4Y = T3Q - T3X; + T4Z = T44 - T41; + T50 = FNMS(KP1_662939224, T4Z, KP1_111140466 * T4Y); + T5c = FMA(KP1_662939224, T4Y, KP1_111140466 * T4Z); + { + E T52, T53, T55, T56; + T52 = T4a - T4h; + T53 = T4A - T4z; + T54 = T52 + T53; + T5e = T52 - T53; + T55 = T4p - T4w; + T56 = T4H - T4E; + T57 = T55 + T56; + T5f = T56 - T55; + } + { + E T51, T58, T5h, T5i; + T51 = T4X + T50; + T58 = FNMS(KP942793473, T57, KP1_763842528 * T54); + O[WS(os, 37)] = T51 - T58; + O[WS(os, 5)] = T51 + T58; + T5h = T5b + T5c; + T5i = FMA(KP1_913880671, T5e, KP580569354 * T5f); + O[WS(os, 29)] = T5h - T5i; + O[WS(os, 61)] = T5h + T5i; + } + { + E T59, T5a, T5d, T5g; + T59 = T4X - T50; + T5a = FMA(KP942793473, T54, KP1_763842528 * T57); + O[WS(os, 21)] = T59 - T5a; + O[WS(os, 53)] = T59 + T5a; + T5d = T5b - T5c; + T5g = FNMS(KP1_913880671, T5f, KP580569354 * T5e); + O[WS(os, 45)] = T5d - T5g; + O[WS(os, 13)] = T5d + T5g; + } + } + } +} + +static void mhc2r_64(const R *ri, const R *ii, R *O, stride ris, stride iis, stride os, int v, int ivs, int ovs) +{ + int i; + for (i = v; i > 0; --i) { + mhc2r_64_0(ri, ii, O, ris, iis, os); + ri += ivs; + ii += ivs; + O += ovs; + } +} + +static const khc2r_desc desc = { 64, "mhc2r_64", {342, 82, 52, 0}, &GENUS, 0, 0, 0, 0, 0 }; + +void X(codelet_mhc2r_64) (planner *p) { + X(khc2r_register) (p, mhc2r_64, &desc); +} |