diff options
Diffstat (limited to 'src/fftw3/rdft/codelets/r2hc')
54 files changed, 16439 insertions, 0 deletions
diff --git a/src/fftw3/rdft/codelets/r2hc/hf2_16.c b/src/fftw3/rdft/codelets/r2hc/hf2_16.c new file mode 100644 index 0000000..47323ee --- /dev/null +++ b/src/fftw3/rdft/codelets/r2hc/hf2_16.c @@ -0,0 +1,411 @@ +/* + * 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 21:57:30 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_hc2hc -compact -variables 4 -twiddle-log3 -n 16 -dit -name hf2_16 -include hf.h */ + +/* + * This function contains 196 FP additions, 108 FP multiplications, + * (or, 156 additions, 68 multiplications, 40 fused multiply/add), + * 104 stack variables, and 64 memory accesses + */ +/* + * Generator Id's : + * $Id: hf2_16.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: hf2_16.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: hf2_16.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + */ + +#include "hf.h" + +static const R *hf2_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 + 8) { + E T1, T3d, T18, T26, T29, T2R, Tq, T1r, T1E, T2k, T2g, T1O, Te, T3c, Tz; + E T1P, T1S, T1T, T1U, TG, TL, T1V, T1Y, T1Z, T20, TT, TY, T1X, T1A, T2l; + E T1J, T2h, T1h, T2b, T1m, T2a; + T1 = rio[0]; + T3d = iio[-WS(ios, 15)]; + { + E T9, T1z, Td, T1v, T1I, Tl, Tp, T1G, Tu, T1D, TD, Ty, T1C, T1l, TX; + E TK, T1g, TI, T1j, TF, T1c, TQ, TS, T1p, T1q, TV, T2, T5, Ti, Tg; + E T4, Tw, Ts, Ta, Tv, T7, Tb, Tr, Tk, TW, TJ, TC, TU, To, TE; + E TH, T14, T24, T17, T25, TN, TO, TP, TR; + T9 = rio[WS(ios, 8)]; + T1z = iio[-WS(ios, 8)]; + Td = iio[-WS(ios, 7)]; + T1v = rio[WS(ios, 7)]; + T1I = iio[-WS(ios, 4)]; + Tl = rio[WS(ios, 4)]; + Tp = iio[-WS(ios, 11)]; + T1G = rio[WS(ios, 11)]; + Tu = rio[WS(ios, 12)]; + T1D = iio[-WS(ios, 12)]; + TD = rio[WS(ios, 2)]; + Ty = iio[-WS(ios, 3)]; + T1C = rio[WS(ios, 3)]; + T1l = iio[-WS(ios, 2)]; + TX = iio[-WS(ios, 9)]; + TK = iio[-WS(ios, 5)]; + T1g = iio[-WS(ios, 10)]; + TI = rio[WS(ios, 10)]; + T1j = rio[WS(ios, 13)]; + TF = iio[-WS(ios, 13)]; + T1c = rio[WS(ios, 5)]; + TQ = rio[WS(ios, 14)]; + TS = iio[-WS(ios, 1)]; + T1p = rio[WS(ios, 15)]; + T1q = iio[0]; + TV = rio[WS(ios, 6)]; + { + E T12, T16, T13, T15, T3, T6, Tm, Tj, Tn, Th; + T12 = rio[WS(ios, 1)]; + T16 = iio[-WS(ios, 6)]; + T13 = iio[-WS(ios, 14)]; + T15 = rio[WS(ios, 9)]; + T2 = W[4]; + T5 = W[5]; + T3 = W[0]; + T6 = W[1]; + Ti = W[3]; + Tg = W[2]; + T4 = T2 * T3; + Tw = T5 * Tg; + Ts = T5 * Ti; + Ta = T2 * T6; + Tv = T2 * Ti; + T7 = T5 * T6; + Tb = T5 * T3; + Tr = T2 * Tg; + Tm = Tg * T6; + Tj = Ti * T6; + Tn = Ti * T3; + Th = Tg * T3; + Tk = Th - Tj; + TW = Tv - Tw; + TJ = Ta + Tb; + TC = Th + Tj; + TU = Tr + Ts; + To = Tm + Tn; + TE = Tm - Tn; + TH = T4 - T7; + T14 = FMA(T3, T12, T6 * T13); + T24 = FNMS(T6, T12, T3 * T13); + T17 = FMA(T2, T15, T5 * T16); + T25 = FNMS(T5, T15, T2 * T16); + TN = W[6]; + TO = W[7]; + TP = FMA(TN, T3, TO * T6); + TR = FNMS(TO, T3, TN * T6); + } + T18 = T14 + T17; + T26 = T24 - T25; + T29 = T14 - T17; + T2R = T24 + T25; + Tq = FMA(Tk, Tl, To * Tp); + T1r = FMA(TN, T1p, TO * T1q); + T1E = FMA(Tg, T1C, Ti * T1D); + T2k = FNMS(TO, T1p, TN * T1q); + T2g = FNMS(Ti, T1C, Tg * T1D); + { + E T8, Tc, Tt, Tx; + T1O = FNMS(To, Tl, Tk * Tp); + T8 = T4 + T7; + Tc = Ta - Tb; + Te = FNMS(Tc, Td, T8 * T9); + T3c = FMA(Tc, T9, T8 * Td); + Tt = Tr - Ts; + Tx = Tv + Tw; + Tz = FMA(Tt, Tu, Tx * Ty); + T1P = FNMS(Tx, Tu, Tt * Ty); + T1S = FMA(TE, TD, TC * TF); + T1T = FNMS(TJ, TI, TH * TK); + T1U = T1S - T1T; + } + TG = FNMS(TE, TF, TC * TD); + TL = FMA(TH, TI, TJ * TK); + T1V = TG - TL; + T1Y = FMA(TR, TQ, TP * TS); + T1Z = FMA(TW, TV, TU * TX); + T20 = T1Y - T1Z; + TT = FNMS(TR, TS, TP * TQ); + TY = FNMS(TW, TX, TU * TV); + T1X = TT - TY; + { + E T1u, T1F, T1y, T1H; + { + E T1s, T1t, T1w, T1x; + T1s = T2 * TC; + T1t = T5 * TE; + T1u = T1s - T1t; + T1F = T1s + T1t; + T1w = T2 * TE; + T1x = T5 * TC; + T1y = T1w + T1x; + T1H = T1w - T1x; + } + T1A = FMA(T1u, T1v, T1y * T1z); + T2l = FNMS(T1y, T1v, T1u * T1z); + T1J = FNMS(T1H, T1I, T1F * T1G); + T2h = FMA(T1H, T1G, T1F * T1I); + } + { + E T1b, T1i, T1f, T1k; + { + E T19, T1a, T1d, T1e; + T19 = T2 * Tk; + T1a = T5 * To; + T1b = T19 + T1a; + T1i = T19 - T1a; + T1d = T2 * To; + T1e = T5 * Tk; + T1f = T1d - T1e; + T1k = T1d + T1e; + } + T1h = FNMS(T1f, T1g, T1b * T1c); + T2b = FNMS(T1k, T1j, T1i * T1l); + T1m = FMA(T1i, T1j, T1k * T1l); + T2a = FMA(T1f, T1c, T1b * T1g); + } + } + { + E TB, T2L, T10, T3k, T3f, T3l, T2O, T3a, T1o, T36, T2U, T32, T1L, T37, T2Z; + E T33; + { + E Tf, TA, T2M, T2N; + Tf = T1 + Te; + TA = Tq + Tz; + TB = Tf + TA; + T2L = Tf - TA; + { + E TM, TZ, T3b, T3e; + TM = TG + TL; + TZ = TT + TY; + T10 = TM + TZ; + T3k = TZ - TM; + T3b = T1O + T1P; + T3e = T3c + T3d; + T3f = T3b + T3e; + T3l = T3e - T3b; + } + T2M = T1S + T1T; + T2N = T1Y + T1Z; + T2O = T2M - T2N; + T3a = T2M + T2N; + { + E T1n, T2Q, T2S, T2T; + T1n = T1h + T1m; + T2Q = T18 - T1n; + T2S = T2a + T2b; + T2T = T2R - T2S; + T1o = T18 + T1n; + T36 = T2R + T2S; + T2U = T2Q + T2T; + T32 = T2T - T2Q; + } + { + E T1B, T1K, T2V, T2W, T2X, T2Y; + T1B = T1r + T1A; + T1K = T1E + T1J; + T2V = T1B - T1K; + T2W = T2k + T2l; + T2X = T2g + T2h; + T2Y = T2W - T2X; + T1L = T1B + T1K; + T37 = T2W + T2X; + T2Z = T2V - T2Y; + T33 = T2V + T2Y; + } + } + { + E T11, T1M, T39, T3g; + T11 = TB + T10; + T1M = T1o + T1L; + iio[-WS(ios, 8)] = T11 - T1M; + rio[0] = T11 + T1M; + T39 = T36 + T37; + T3g = T3a + T3f; + rio[WS(ios, 8)] = T39 - T3g; + iio[0] = T39 + T3g; + } + { + E T2P, T30, T3j, T3m; + T2P = T2L + T2O; + T30 = KP707106781 * (T2U + T2Z); + iio[-WS(ios, 10)] = T2P - T30; + rio[WS(ios, 2)] = T2P + T30; + T3j = KP707106781 * (T32 + T33); + T3m = T3k + T3l; + rio[WS(ios, 10)] = T3j - T3m; + iio[-WS(ios, 2)] = T3j + T3m; + } + { + E T31, T34, T3n, T3o; + T31 = T2L - T2O; + T34 = KP707106781 * (T32 - T33); + iio[-WS(ios, 14)] = T31 - T34; + rio[WS(ios, 6)] = T31 + T34; + T3n = KP707106781 * (T2Z - T2U); + T3o = T3l - T3k; + rio[WS(ios, 14)] = T3n - T3o; + iio[-WS(ios, 6)] = T3n + T3o; + } + { + E T35, T38, T3h, T3i; + T35 = TB - T10; + T38 = T36 - T37; + iio[-WS(ios, 12)] = T35 - T38; + rio[WS(ios, 4)] = T35 + T38; + T3h = T1L - T1o; + T3i = T3f - T3a; + rio[WS(ios, 12)] = T3h - T3i; + iio[-WS(ios, 4)] = T3h + T3i; + } + } + { + E T1R, T2v, T22, T3q, T3t, T3z, T2y, T3y, T2e, T2I, T2s, T2C, T2p, T2J, T2t; + E T2F; + { + E T1N, T1Q, T2w, T2x; + T1N = T1 - Te; + T1Q = T1O - T1P; + T1R = T1N - T1Q; + T2v = T1N + T1Q; + { + E T1W, T21, T3r, T3s; + T1W = T1U - T1V; + T21 = T1X + T20; + T22 = KP707106781 * (T1W - T21); + T3q = KP707106781 * (T1W + T21); + T3r = T3d - T3c; + T3s = Tq - Tz; + T3t = T3r - T3s; + T3z = T3s + T3r; + } + T2w = T1V + T1U; + T2x = T1X - T20; + T2y = KP707106781 * (T2w + T2x); + T3y = KP707106781 * (T2x - T2w); + { + E T28, T2A, T2d, T2B, T27, T2c; + T27 = T1h - T1m; + T28 = T26 + T27; + T2A = T26 - T27; + T2c = T2a - T2b; + T2d = T29 - T2c; + T2B = T29 + T2c; + T2e = FMA(KP923879532, T28, KP382683432 * T2d); + T2I = FNMS(KP382683432, T2B, KP923879532 * T2A); + T2s = FNMS(KP923879532, T2d, KP382683432 * T28); + T2C = FMA(KP382683432, T2A, KP923879532 * T2B); + } + { + E T2j, T2D, T2o, T2E; + { + E T2f, T2i, T2m, T2n; + T2f = T1r - T1A; + T2i = T2g - T2h; + T2j = T2f - T2i; + T2D = T2f + T2i; + T2m = T2k - T2l; + T2n = T1E - T1J; + T2o = T2m + T2n; + T2E = T2m - T2n; + } + T2p = FNMS(KP923879532, T2o, KP382683432 * T2j); + T2J = FMA(KP923879532, T2E, KP382683432 * T2D); + T2t = FMA(KP382683432, T2o, KP923879532 * T2j); + T2F = FNMS(KP382683432, T2E, KP923879532 * T2D); + } + } + { + E T23, T2q, T3x, T3A; + T23 = T1R + T22; + T2q = T2e + T2p; + iio[-WS(ios, 11)] = T23 - T2q; + rio[WS(ios, 3)] = T23 + T2q; + T3x = T2s + T2t; + T3A = T3y + T3z; + rio[WS(ios, 11)] = T3x - T3A; + iio[-WS(ios, 3)] = T3x + T3A; + } + { + E T2r, T2u, T3B, T3C; + T2r = T1R - T22; + T2u = T2s - T2t; + iio[-WS(ios, 15)] = T2r - T2u; + rio[WS(ios, 7)] = T2r + T2u; + T3B = T2p - T2e; + T3C = T3z - T3y; + rio[WS(ios, 15)] = T3B - T3C; + iio[-WS(ios, 7)] = T3B + T3C; + } + { + E T2z, T2G, T3p, T3u; + T2z = T2v + T2y; + T2G = T2C + T2F; + iio[-WS(ios, 9)] = T2z - T2G; + rio[WS(ios, 1)] = T2z + T2G; + T3p = T2I + T2J; + T3u = T3q + T3t; + rio[WS(ios, 9)] = T3p - T3u; + iio[-WS(ios, 1)] = T3p + T3u; + } + { + E T2H, T2K, T3v, T3w; + T2H = T2v - T2y; + T2K = T2I - T2J; + iio[-WS(ios, 13)] = T2H - T2K; + rio[WS(ios, 5)] = T2H + T2K; + T3v = T2F - T2C; + T3w = T3t - T3q; + rio[WS(ios, 13)] = T3v - T3w; + iio[-WS(ios, 5)] = T3v + T3w; + } + } + } + return W; +} + +static const tw_instr twinstr[] = { + {TW_COS, 0, 1}, + {TW_SIN, 0, 1}, + {TW_COS, 0, 3}, + {TW_SIN, 0, 3}, + {TW_COS, 0, 9}, + {TW_SIN, 0, 9}, + {TW_COS, 0, 15}, + {TW_SIN, 0, 15}, + {TW_NEXT, 1, 0} +}; + +static const hc2hc_desc desc = { 16, "hf2_16", twinstr, {156, 68, 40, 0}, &GENUS, 0, 0, 0 }; + +void X(codelet_hf2_16) (planner *p) { + X(khc2hc_dit_register) (p, hf2_16, &desc); +} diff --git a/src/fftw3/rdft/codelets/r2hc/hf2_32.c b/src/fftw3/rdft/codelets/r2hc/hf2_32.c new file mode 100644 index 0000000..56c7769 --- /dev/null +++ b/src/fftw3/rdft/codelets/r2hc/hf2_32.c @@ -0,0 +1,853 @@ +/* + * 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 21:57:34 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_hc2hc -compact -variables 4 -twiddle-log3 -n 32 -dit -name hf2_32 -include hf.h */ + +/* + * This function contains 488 FP additions, 280 FP multiplications, + * (or, 376 additions, 168 multiplications, 112 fused multiply/add), + * 204 stack variables, and 128 memory accesses + */ +/* + * Generator Id's : + * $Id: hf2_32.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: hf2_32.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: hf2_32.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + */ + +#include "hf.h" + +static const R *hf2_32(R *rio, R *iio, const R *W, stride ios, int m, int dist) +{ + DK(KP831469612, +0.831469612302545237078788377617905756738560812); + DK(KP555570233, +0.555570233019602224742830813948532874374937191); + DK(KP195090322, +0.195090322016128267848284868477022240927691618); + DK(KP980785280, +0.980785280403230449126182236134239036973933731); + DK(KP707106781, +0.707106781186547524400844362104849039284835938); + DK(KP923879532, +0.923879532511286756128183189396788286822416626); + DK(KP382683432, +0.382683432365089771728459984030398866761344562); + int i; + for (i = m - 2; i > 0; i = i - 2, rio = rio + dist, iio = iio - dist, W = W + 8) { + E T1, T3t, T4S, TQ, T3G, T49, T20, T2n, T4y, T1J, T43, T2w, T4z, T36, T4Z; + E TK, T8b, T40, T6l, T3U, T6k, T1h, T3L, T1D, T3V, T1s, T3X, T3E, T7E, T3O; + E T6h, T2k, T6w, T4i, T4x, T3q, T6I, T4O, T4P, T3w, T4T, T4R, T4U, Tm, To; + E TX, T4I, T3a, T3H, T31, T4Y, T3f, T4J, T2G, T4s, T4r, T2B, T4q, T4t, T27; + E T4a, T2M, T4m, T4n, T2P, T4l, T4o, T1U, T44, Tn, Tp, T7G; + T1 = rio[0]; + { + E Tv, T3e, Tz, T3c, T39, TE, TI, T38, TN, T3v, TU, T1l, T3u, TW, T12; + E T35, T1f, T3m, T1b, T3o, T30, T2L, T16, T1k, T33, T2W, TP, T2J, T2D, T1w; + E T1z, T2A, T1B, T2z, T2F, T1u, T2N, T1q, T1I, T2O, T1o, T1G, T2m, T24, T1Z; + E T2r, T1X, T2v, T2l, T26, T2i, T1R, T1T, T2g, T2, Ti, T3, Tc, TF, TC; + E TG, TB, Tu, T1a, T15, Ty, T1t, T1Y, T1W, T1v, TH, T1y, T11, TD, T1A; + E T1e, T4g, T3k, T1n, T1p, T2e, T4M, TM, T1K, T1O, TO, T1L, T1N, Ta, Tb; + E T2t, Tk, T2o, Tf, Tg, T2s, Tj, T2p; + Tv = rio[WS(ios, 8)]; + T3e = iio[-WS(ios, 8)]; + Tz = iio[-WS(ios, 23)]; + T3c = rio[WS(ios, 23)]; + T39 = iio[-WS(ios, 24)]; + TE = rio[WS(ios, 24)]; + TI = iio[-WS(ios, 7)]; + T38 = rio[WS(ios, 7)]; + TN = rio[WS(ios, 4)]; + T3v = iio[-WS(ios, 20)]; + TU = rio[WS(ios, 20)]; + T1l = iio[-WS(ios, 29)]; + T3u = rio[WS(ios, 11)]; + TW = iio[-WS(ios, 11)]; + T12 = rio[WS(ios, 28)]; + T35 = iio[-WS(ios, 16)]; + T1f = iio[-WS(ios, 19)]; + T3m = rio[WS(ios, 19)]; + T1b = rio[WS(ios, 12)]; + T3o = iio[-WS(ios, 12)]; + T30 = iio[0]; + T2L = iio[-WS(ios, 2)]; + T16 = iio[-WS(ios, 3)]; + T1k = rio[WS(ios, 2)]; + T33 = rio[WS(ios, 15)]; + T2W = rio[WS(ios, 31)]; + TP = iio[-WS(ios, 27)]; + T2J = rio[WS(ios, 29)]; + T2D = rio[WS(ios, 21)]; + T1w = iio[-WS(ios, 21)]; + T1z = rio[WS(ios, 26)]; + T2A = iio[-WS(ios, 26)]; + T1B = iio[-WS(ios, 5)]; + T2z = rio[WS(ios, 5)]; + T2F = iio[-WS(ios, 10)]; + T1u = rio[WS(ios, 10)]; + T2N = rio[WS(ios, 13)]; + T1q = iio[-WS(ios, 13)]; + T1I = iio[-WS(ios, 1)]; + T2O = iio[-WS(ios, 18)]; + T1o = rio[WS(ios, 18)]; + T1G = rio[WS(ios, 30)]; + T2m = iio[-WS(ios, 22)]; + T24 = rio[WS(ios, 22)]; + T1Z = iio[-WS(ios, 25)]; + T2r = rio[WS(ios, 25)]; + T1X = rio[WS(ios, 6)]; + T2v = iio[-WS(ios, 6)]; + T2l = rio[WS(ios, 9)]; + T26 = iio[-WS(ios, 9)]; + T2i = iio[-WS(ios, 14)]; + T1R = rio[WS(ios, 14)]; + T1T = iio[-WS(ios, 17)]; + T2g = rio[WS(ios, 17)]; + { + E T2c, T2d, T3s, T3r, T3j, T3i, T4, T7, T5, T8, T6, T9, T14, T1d, Ts; + E T18, T19, T1c, Te, Td, Tt, Tw, T13, TZ, T10, Tx; + T2c = rio[WS(ios, 1)]; + T2d = iio[-WS(ios, 30)]; + T3s = iio[-WS(ios, 4)]; + T3r = rio[WS(ios, 27)]; + T3j = iio[-WS(ios, 28)]; + T3i = rio[WS(ios, 3)]; + T2 = W[6]; + Ti = W[7]; + T3 = W[4]; + Tc = W[5]; + T4 = W[2]; + T7 = W[3]; + T5 = W[0]; + T8 = W[1]; + T6 = T4 * T5; + T9 = T7 * T8; + T14 = Ti * T5; + T1d = Tc * T4; + Ts = T3 * T5; + T18 = T3 * T4; + T19 = Tc * T7; + T1c = T3 * T7; + Te = T7 * T5; + Td = T4 * T8; + Tt = Tc * T8; + Tw = T3 * T8; + TF = T2 * T7; + T13 = T2 * T8; + TC = Ti * T7; + TG = Ti * T4; + TZ = T2 * T5; + T10 = Ti * T8; + TB = T2 * T4; + Tx = Tc * T5; + Tu = Ts + Tt; + T1a = T18 - T19; + T15 = T13 + T14; + Ty = Tw - Tx; + T1t = Ts - Tt; + T1Y = T1c - T1d; + T1W = T18 + T19; + T1v = Tw + Tx; + TH = TF - TG; + T1y = TZ + T10; + T11 = TZ - T10; + TD = TB + TC; + T1A = T13 - T14; + T1e = T1c + T1d; + T3t = FMA(T2, T3r, Ti * T3s); + T4g = FNMS(T8, T2c, T5 * T2d); + T4S = FNMS(Ti, T3r, T2 * T3s); + T3k = FMA(T4, T3i, T7 * T3j); + T1n = FMA(T2, T3, Ti * Tc); + T1p = FNMS(Ti, T3, T2 * Tc); + T2e = FMA(T5, T2c, T8 * T2d); + T4M = FNMS(T7, T3i, T4 * T3j); + TM = T6 - T9; + T1K = T3 * TM; + T1O = Tc * TM; + TO = Td + Te; + T1L = Tc * TO; + T1N = T3 * TO; + Ta = T6 + T9; + Tb = T3 * Ta; + T2t = Ti * Ta; + Tk = Tc * Ta; + T2o = T2 * Ta; + Tf = Td - Te; + Tg = Tc * Tf; + T2s = T2 * Tf; + Tj = T3 * Tf; + T2p = Ti * Tf; + } + TQ = FMA(TM, TN, TO * TP); + T3G = FNMS(TO, TN, TM * TP); + T49 = FMA(T1Y, T1X, T1W * T1Z); + T20 = FNMS(T1Y, T1Z, T1W * T1X); + T2n = FMA(T3, T2l, Tc * T2m); + T4y = FNMS(Tc, T2l, T3 * T2m); + { + E T1F, T1H, TA, TJ; + T1F = TB - TC; + T1H = TF + TG; + T1J = FMA(T1F, T1G, T1H * T1I); + T43 = FNMS(T1H, T1G, T1F * T1I); + { + E T2q, T2u, T32, T34; + T2q = T2o - T2p; + T2u = T2s + T2t; + T2w = FMA(T2q, T2r, T2u * T2v); + T4z = FNMS(T2u, T2r, T2q * T2v); + T32 = FMA(T2, T1a, Ti * T1e); + T34 = FNMS(Ti, T1a, T2 * T1e); + T36 = FNMS(T34, T35, T32 * T33); + T4Z = FMA(T34, T33, T32 * T35); + } + TA = FNMS(Ty, Tz, Tu * Tv); + TJ = FNMS(TH, TI, TD * TE); + TK = TA + TJ; + T8b = TA - TJ; + { + E T3Y, T3Z, T3S, T3T; + T3Y = FNMS(T1v, T1u, T1t * T1w); + T3Z = FMA(T1A, T1z, T1y * T1B); + T40 = T3Y - T3Z; + T6l = T3Y + T3Z; + T3S = FMA(Tf, T1k, Ta * T1l); + T3T = FMA(T1p, T1o, T1n * T1q); + T3U = T3S - T3T; + T6k = T3S + T3T; + } + } + { + E T17, T1g, Th, Tl; + T17 = FMA(T11, T12, T15 * T16); + T1g = FMA(T1a, T1b, T1e * T1f); + T1h = T17 + T1g; + T3L = T17 - T1g; + { + E T1x, T1C, T1m, T1r; + T1x = FMA(T1t, T1u, T1v * T1w); + T1C = FNMS(T1A, T1B, T1y * T1z); + T1D = T1x + T1C; + T3V = T1x - T1C; + T1m = FNMS(Tf, T1l, Ta * T1k); + T1r = FNMS(T1p, T1q, T1n * T1o); + T1s = T1m + T1r; + T3X = T1m - T1r; + } + { + E T3C, T3D, T3M, T3N; + T3C = FMA(Ty, Tv, Tu * Tz); + T3D = FMA(TH, TE, TD * TI); + T3E = T3C - T3D; + T7E = T3C + T3D; + T3M = FNMS(T15, T12, T11 * T16); + T3N = FNMS(T1e, T1b, T1a * T1f); + T3O = T3M - T3N; + T6h = T3M + T3N; + { + E T2j, T4h, T2f, T2h; + T2f = FMA(T2, T1t, Ti * T1v); + T2h = FNMS(Ti, T1t, T2 * T1v); + T2j = FNMS(T2h, T2i, T2f * T2g); + T4h = FMA(T2h, T2g, T2f * T2i); + T2k = T2e + T2j; + T6w = T4g + T4h; + T4i = T4g - T4h; + T4x = T2e - T2j; + } + } + { + E T3p, T4N, T3l, T3n; + T3l = FNMS(Ti, Ty, T2 * Tu); + T3n = FMA(T2, Ty, Ti * Tu); + T3p = FMA(T3l, T3m, T3n * T3o); + T4N = FNMS(T3n, T3m, T3l * T3o); + T3q = T3k + T3p; + T6I = T4M + T4N; + T4O = T4M - T4N; + T4P = T3k - T3p; + } + Th = Tb + Tg; + Tl = Tj - Tk; + T3w = FNMS(Tl, T3v, Th * T3u); + T4T = FMA(Tl, T3u, Th * T3v); + T4R = T3t - T3w; + T4U = T4S - T4T; + Tm = FNMS(Ti, Tl, T2 * Th); + To = FMA(T2, Tl, Ti * Th); + { + E TR, TS, TT, TV; + TR = Tb - Tg; + TS = Tj + Tk; + TT = FMA(T2, TR, Ti * TS); + TV = FNMS(Ti, TR, T2 * TS); + TX = FNMS(TV, TW, TT * TU); + T4I = FNMS(TS, T38, TR * T39); + T3a = FMA(TR, T38, TS * T39); + T3H = FMA(TV, TU, TT * TW); + } + { + E T2V, T3b, T2Z, T3d; + { + E T2T, T2U, T2X, T2Y; + T2T = T2 * TM; + T2U = Ti * TO; + T2V = T2T - T2U; + T3b = T2T + T2U; + T2X = T2 * TO; + T2Y = Ti * TM; + T2Z = T2X + T2Y; + T3d = T2X - T2Y; + } + T31 = FMA(T2V, T2W, T2Z * T30); + T4Y = FNMS(T2Z, T2W, T2V * T30); + T3f = FNMS(T3d, T3e, T3b * T3c); + T4J = FMA(T3d, T3c, T3b * T3e); + } + { + E T23, T25, T1Q, T1S; + { + E T2C, T2E, T21, T22; + T2C = FNMS(Ti, T1Y, T2 * T1W); + T2E = FMA(T2, T1Y, Ti * T1W); + T2G = FMA(T2C, T2D, T2E * T2F); + T4s = FNMS(T2E, T2D, T2C * T2F); + T21 = T1K + T1L; + T22 = T1N - T1O; + T23 = FNMS(Ti, T22, T2 * T21); + T4r = FMA(T22, T2z, T21 * T2A); + T25 = FMA(T2, T22, Ti * T21); + T2B = FNMS(T22, T2A, T21 * T2z); + } + T4q = T2B - T2G; + T4t = T4r - T4s; + T27 = FMA(T23, T24, T25 * T26); + T4a = FNMS(T25, T24, T23 * T26); + { + E T2I, T2K, T1M, T1P; + T2I = T2o + T2p; + T2K = T2s - T2t; + T2M = FNMS(T2K, T2L, T2I * T2J); + T4m = FMA(T2K, T2J, T2I * T2L); + T1M = T1K - T1L; + T1P = T1N + T1O; + T1Q = FMA(T2, T1M, Ti * T1P); + T4n = FNMS(T1P, T2N, T1M * T2O); + T1S = FNMS(Ti, T1M, T2 * T1P); + T2P = FMA(T1M, T2N, T1P * T2O); + } + T4l = T2M - T2P; + T4o = T4m - T4n; + T1U = FNMS(T1S, T1T, T1Q * T1R); + T44 = FMA(T1S, T1R, T1Q * T1T); + } + } + } + Tn = rio[WS(ios, 16)]; + Tp = iio[-WS(ios, 15)]; + T7G = iio[-WS(ios, 31)]; + { + E T1i, T7V, T6i, T7D, T42, T5e, T5A, T60, T6o, T6Y, TL, T6f, T3F, T5t, T7I; + E T8q, T7W, T8c, T3Q, T8p, T5w, T89, T4d, T61, T5f, T5D, T2a, T6t, T7O, T7C; + E T7g, T6Z, T4w, T64, T65, T4F, T5i, T5I, T5L, T5j, T2S, T7l, T7y, T6A, T6F; + E T73, T7i, T72, T4X, T67, T68, T56, T5l, T5P, T5S, T5m, T3z, T7q, T7z, T6L; + E T6Q, T76, T7n, T75; + { + E TY, T6g, T3W, T41; + TY = TQ + TX; + T1i = TY + T1h; + T7V = T1h - TY; + T6g = T3G + T3H; + T6i = T6g - T6h; + T7D = T6g + T6h; + T3W = T3U + T3V; + T41 = T3X - T40; + T42 = FNMS(KP923879532, T41, KP382683432 * T3W); + T5e = FMA(KP923879532, T3W, KP382683432 * T41); + } + { + E T5y, T5z, T6m, T6n; + T5y = T3U - T3V; + T5z = T3X + T40; + T5A = FNMS(KP382683432, T5z, KP923879532 * T5y); + T60 = FMA(KP382683432, T5y, KP923879532 * T5z); + T6m = T6k - T6l; + T6n = T1s - T1D; + T6o = T6m - T6n; + T6Y = T6n + T6m; + } + { + E Tr, T3B, Tq, T7H, T8a, T7F; + Tq = FMA(Tm, Tn, To * Tp); + Tr = T1 + Tq; + T3B = T1 - Tq; + TL = Tr + TK; + T6f = Tr - TK; + T3F = T3B - T3E; + T5t = T3B + T3E; + T7F = FNMS(To, Tn, Tm * Tp); + T7H = T7F + T7G; + T8a = T7G - T7F; + T7I = T7E + T7H; + T8q = T8b + T8a; + T7W = T7H - T7E; + T8c = T8a - T8b; + } + { + E T3P, T5v, T3K, T5u, T3I, T3J; + T3P = T3L + T3O; + T5v = T3L - T3O; + T3I = T3G - T3H; + T3J = TQ - TX; + T3K = T3I - T3J; + T5u = T3J + T3I; + T3Q = KP707106781 * (T3K - T3P); + T8p = KP707106781 * (T5v - T5u); + T5w = KP707106781 * (T5u + T5v); + T89 = KP707106781 * (T3K + T3P); + } + { + E T47, T5B, T4c, T5C; + { + E T45, T46, T48, T4b; + T45 = T43 - T44; + T46 = T20 - T27; + T47 = T45 + T46; + T5B = T45 - T46; + T48 = T1J - T1U; + T4b = T49 - T4a; + T4c = T48 - T4b; + T5C = T48 + T4b; + } + T4d = FMA(KP382683432, T47, KP923879532 * T4c); + T61 = FNMS(KP382683432, T5B, KP923879532 * T5C); + T5f = FNMS(KP923879532, T47, KP382683432 * T4c); + T5D = FMA(KP923879532, T5B, KP382683432 * T5C); + } + { + E T1E, T7e, T29, T6p, T6s, T7f; + T1E = T1s + T1D; + T7e = T6k + T6l; + { + E T1V, T28, T6q, T6r; + T1V = T1J + T1U; + T28 = T20 + T27; + T29 = T1V + T28; + T6p = T1V - T28; + T6q = T43 + T44; + T6r = T49 + T4a; + T6s = T6q - T6r; + T7f = T6q + T6r; + } + T2a = T1E + T29; + T6t = T6p + T6s; + T7O = T29 - T1E; + T7C = T7e + T7f; + T7g = T7e - T7f; + T6Z = T6p - T6s; + } + { + E T4k, T5J, T4B, T5G, T4v, T5H, T4E, T5K, T4j, T4A; + T4j = T2n - T2w; + T4k = T4i + T4j; + T5J = T4i - T4j; + T4A = T4y - T4z; + T4B = T4x - T4A; + T5G = T4x + T4A; + { + E T4p, T4u, T4C, T4D; + T4p = T4l - T4o; + T4u = T4q + T4t; + T4v = KP707106781 * (T4p - T4u); + T5H = KP707106781 * (T4u + T4p); + T4C = T4t - T4q; + T4D = T4l + T4o; + T4E = KP707106781 * (T4C - T4D); + T5K = KP707106781 * (T4C + T4D); + } + T4w = T4k - T4v; + T64 = T5G + T5H; + T65 = T5J + T5K; + T4F = T4B - T4E; + T5i = T4k + T4v; + T5I = T5G - T5H; + T5L = T5J - T5K; + T5j = T4B + T4E; + } + { + E T2y, T6B, T6y, T7j, T2R, T6z, T6E, T7k, T2x, T6x; + T2x = T2n + T2w; + T2y = T2k + T2x; + T6B = T2k - T2x; + T6x = T4y + T4z; + T6y = T6w - T6x; + T7j = T6w + T6x; + { + E T2H, T2Q, T6C, T6D; + T2H = T2B + T2G; + T2Q = T2M + T2P; + T2R = T2H + T2Q; + T6z = T2Q - T2H; + T6C = T4r + T4s; + T6D = T4m + T4n; + T6E = T6C - T6D; + T7k = T6C + T6D; + } + T2S = T2y + T2R; + T7l = T7j - T7k; + T7y = T7j + T7k; + T6A = T6y - T6z; + T6F = T6B - T6E; + T73 = T6B + T6E; + T7i = T2y - T2R; + T72 = T6y + T6z; + } + { + E T4L, T5N, T55, T5O, T4W, T5R, T52, T5Q; + { + E T4H, T4K, T53, T54; + T4H = T31 - T36; + T4K = T4I - T4J; + T4L = T4H - T4K; + T5N = T4H + T4K; + T53 = T4R - T4U; + T54 = T4P + T4O; + T55 = KP707106781 * (T53 - T54); + T5O = KP707106781 * (T54 + T53); + } + { + E T4Q, T4V, T50, T51; + T4Q = T4O - T4P; + T4V = T4R + T4U; + T4W = KP707106781 * (T4Q - T4V); + T5R = KP707106781 * (T4Q + T4V); + T50 = T4Y - T4Z; + T51 = T3a - T3f; + T52 = T50 + T51; + T5Q = T50 - T51; + } + T4X = T4L - T4W; + T67 = T5N + T5O; + T68 = T5Q + T5R; + T56 = T52 - T55; + T5l = T4L + T4W; + T5P = T5N - T5O; + T5S = T5Q - T5R; + T5m = T52 + T55; + } + { + E T3y, T6P, T6K, T7p, T3h, T6H, T6O, T7o, T3x, T6J; + T3x = T3t + T3w; + T3y = T3q + T3x; + T6P = T3x - T3q; + T6J = T4S + T4T; + T6K = T6I - T6J; + T7p = T6I + T6J; + { + E T37, T3g, T6M, T6N; + T37 = T31 + T36; + T3g = T3a + T3f; + T3h = T37 + T3g; + T6H = T37 - T3g; + T6M = T4Y + T4Z; + T6N = T4I + T4J; + T6O = T6M - T6N; + T7o = T6M + T6N; + } + T3z = T3h + T3y; + T7q = T7o - T7p; + T7z = T7o + T7p; + T6L = T6H - T6K; + T6Q = T6O - T6P; + T76 = T6O + T6P; + T7n = T3h - T3y; + T75 = T6H + T6K; + } + { + E T3A, T7A, T2b, T7x, T1j; + T3A = T2S + T3z; + T7A = T7y - T7z; + T1j = TL + T1i; + T2b = T1j + T2a; + T7x = T1j - T2a; + iio[-WS(ios, 16)] = T2b - T3A; + rio[WS(ios, 8)] = T7x + T7A; + rio[0] = T2b + T3A; + iio[-WS(ios, 24)] = T7x - T7A; + } + { + E T7B, T7L, T7K, T7M, T7J; + T7B = T7y + T7z; + T7L = T3z - T2S; + T7J = T7D + T7I; + T7K = T7C + T7J; + T7M = T7J - T7C; + rio[WS(ios, 16)] = T7B - T7K; + iio[-WS(ios, 8)] = T7L + T7M; + iio[0] = T7B + T7K; + rio[WS(ios, 24)] = T7L - T7M; + } + { + E T7h, T7t, T7Q, T7S, T7s, T7R, T7w, T7N, T7d, T7P; + T7d = TL - T1i; + T7h = T7d + T7g; + T7t = T7d - T7g; + T7P = T7I - T7D; + T7Q = T7O + T7P; + T7S = T7P - T7O; + { + E T7m, T7r, T7u, T7v; + T7m = T7i + T7l; + T7r = T7n - T7q; + T7s = KP707106781 * (T7m + T7r); + T7R = KP707106781 * (T7r - T7m); + T7u = T7l - T7i; + T7v = T7n + T7q; + T7w = KP707106781 * (T7u - T7v); + T7N = KP707106781 * (T7u + T7v); + } + iio[-WS(ios, 20)] = T7h - T7s; + rio[WS(ios, 20)] = T7N - T7Q; + rio[WS(ios, 4)] = T7h + T7s; + iio[-WS(ios, 4)] = T7N + T7Q; + iio[-WS(ios, 28)] = T7t - T7w; + rio[WS(ios, 28)] = T7R - T7S; + rio[WS(ios, 12)] = T7t + T7w; + iio[-WS(ios, 12)] = T7R + T7S; + } + { + E T71, T79, T7Y, T80, T78, T7Z, T7c, T7T; + { + E T6X, T70, T7U, T7X; + T6X = T6f + T6i; + T70 = KP707106781 * (T6Y + T6Z); + T71 = T6X + T70; + T79 = T6X - T70; + T7U = KP707106781 * (T6o + T6t); + T7X = T7V + T7W; + T7Y = T7U + T7X; + T80 = T7X - T7U; + } + { + E T74, T77, T7a, T7b; + T74 = FMA(KP382683432, T72, KP923879532 * T73); + T77 = FNMS(KP382683432, T76, KP923879532 * T75); + T78 = T74 + T77; + T7Z = T77 - T74; + T7a = FNMS(KP382683432, T73, KP923879532 * T72); + T7b = FMA(KP923879532, T76, KP382683432 * T75); + T7c = T7a - T7b; + T7T = T7a + T7b; + } + iio[-WS(ios, 18)] = T71 - T78; + rio[WS(ios, 18)] = T7T - T7Y; + rio[WS(ios, 2)] = T71 + T78; + iio[-WS(ios, 2)] = T7T + T7Y; + iio[-WS(ios, 26)] = T79 - T7c; + rio[WS(ios, 26)] = T7Z - T80; + rio[WS(ios, 10)] = T79 + T7c; + iio[-WS(ios, 10)] = T7Z + T80; + } + { + E T4f, T59, T8y, T8A, T58, T8z, T5c, T8v; + { + E T3R, T4e, T8w, T8x; + T3R = T3F - T3Q; + T4e = T42 - T4d; + T4f = T3R + T4e; + T59 = T3R - T4e; + T8w = T5f - T5e; + T8x = T8q - T8p; + T8y = T8w + T8x; + T8A = T8x - T8w; + } + { + E T4G, T57, T5a, T5b; + T4G = FMA(KP980785280, T4w, KP195090322 * T4F); + T57 = FNMS(KP980785280, T56, KP195090322 * T4X); + T58 = T4G + T57; + T8z = T57 - T4G; + T5a = FNMS(KP980785280, T4F, KP195090322 * T4w); + T5b = FMA(KP195090322, T56, KP980785280 * T4X); + T5c = T5a - T5b; + T8v = T5a + T5b; + } + iio[-WS(ios, 23)] = T4f - T58; + rio[WS(ios, 23)] = T8v - T8y; + rio[WS(ios, 7)] = T4f + T58; + iio[-WS(ios, 7)] = T8v + T8y; + iio[-WS(ios, 31)] = T59 - T5c; + rio[WS(ios, 31)] = T8z - T8A; + rio[WS(ios, 15)] = T59 + T5c; + iio[-WS(ios, 15)] = T8z + T8A; + } + { + E T5F, T5V, T8k, T8m, T5U, T8l, T5Y, T8h; + { + E T5x, T5E, T8i, T8j; + T5x = T5t - T5w; + T5E = T5A - T5D; + T5F = T5x + T5E; + T5V = T5x - T5E; + T8i = T61 - T60; + T8j = T8c - T89; + T8k = T8i + T8j; + T8m = T8j - T8i; + } + { + E T5M, T5T, T5W, T5X; + T5M = FMA(KP555570233, T5I, KP831469612 * T5L); + T5T = FNMS(KP831469612, T5S, KP555570233 * T5P); + T5U = T5M + T5T; + T8l = T5T - T5M; + T5W = FNMS(KP831469612, T5I, KP555570233 * T5L); + T5X = FMA(KP831469612, T5P, KP555570233 * T5S); + T5Y = T5W - T5X; + T8h = T5W + T5X; + } + iio[-WS(ios, 21)] = T5F - T5U; + rio[WS(ios, 21)] = T8h - T8k; + rio[WS(ios, 5)] = T5F + T5U; + iio[-WS(ios, 5)] = T8h + T8k; + iio[-WS(ios, 29)] = T5V - T5Y; + rio[WS(ios, 29)] = T8l - T8m; + rio[WS(ios, 13)] = T5V + T5Y; + iio[-WS(ios, 13)] = T8l + T8m; + } + { + E T6v, T6T, T84, T86, T6S, T85, T6W, T81; + { + E T6j, T6u, T82, T83; + T6j = T6f - T6i; + T6u = KP707106781 * (T6o - T6t); + T6v = T6j + T6u; + T6T = T6j - T6u; + T82 = KP707106781 * (T6Z - T6Y); + T83 = T7W - T7V; + T84 = T82 + T83; + T86 = T83 - T82; + } + { + E T6G, T6R, T6U, T6V; + T6G = FMA(KP923879532, T6A, KP382683432 * T6F); + T6R = FNMS(KP923879532, T6Q, KP382683432 * T6L); + T6S = T6G + T6R; + T85 = T6R - T6G; + T6U = FNMS(KP923879532, T6F, KP382683432 * T6A); + T6V = FMA(KP382683432, T6Q, KP923879532 * T6L); + T6W = T6U - T6V; + T81 = T6U + T6V; + } + iio[-WS(ios, 22)] = T6v - T6S; + rio[WS(ios, 22)] = T81 - T84; + rio[WS(ios, 6)] = T6v + T6S; + iio[-WS(ios, 6)] = T81 + T84; + iio[-WS(ios, 30)] = T6T - T6W; + rio[WS(ios, 30)] = T85 - T86; + rio[WS(ios, 14)] = T6T + T6W; + iio[-WS(ios, 14)] = T85 + T86; + } + { + E T5h, T5p, T8s, T8u, T5o, T8t, T5s, T8n; + { + E T5d, T5g, T8o, T8r; + T5d = T3F + T3Q; + T5g = T5e + T5f; + T5h = T5d + T5g; + T5p = T5d - T5g; + T8o = T42 + T4d; + T8r = T8p + T8q; + T8s = T8o + T8r; + T8u = T8r - T8o; + } + { + E T5k, T5n, T5q, T5r; + T5k = FMA(KP555570233, T5i, KP831469612 * T5j); + T5n = FNMS(KP555570233, T5m, KP831469612 * T5l); + T5o = T5k + T5n; + T8t = T5n - T5k; + T5q = FNMS(KP555570233, T5j, KP831469612 * T5i); + T5r = FMA(KP831469612, T5m, KP555570233 * T5l); + T5s = T5q - T5r; + T8n = T5q + T5r; + } + iio[-WS(ios, 19)] = T5h - T5o; + rio[WS(ios, 19)] = T8n - T8s; + rio[WS(ios, 3)] = T5h + T5o; + iio[-WS(ios, 3)] = T8n + T8s; + iio[-WS(ios, 27)] = T5p - T5s; + rio[WS(ios, 27)] = T8t - T8u; + rio[WS(ios, 11)] = T5p + T5s; + iio[-WS(ios, 11)] = T8t + T8u; + } + { + E T63, T6b, T8e, T8g, T6a, T8f, T6e, T87; + { + E T5Z, T62, T88, T8d; + T5Z = T5t + T5w; + T62 = T60 + T61; + T63 = T5Z + T62; + T6b = T5Z - T62; + T88 = T5A + T5D; + T8d = T89 + T8c; + T8e = T88 + T8d; + T8g = T8d - T88; + } + { + E T66, T69, T6c, T6d; + T66 = FMA(KP980785280, T64, KP195090322 * T65); + T69 = FNMS(KP195090322, T68, KP980785280 * T67); + T6a = T66 + T69; + T8f = T69 - T66; + T6c = FNMS(KP195090322, T64, KP980785280 * T65); + T6d = FMA(KP195090322, T67, KP980785280 * T68); + T6e = T6c - T6d; + T87 = T6c + T6d; + } + iio[-WS(ios, 17)] = T63 - T6a; + rio[WS(ios, 17)] = T87 - T8e; + rio[WS(ios, 1)] = T63 + T6a; + iio[-WS(ios, 1)] = T87 + T8e; + iio[-WS(ios, 25)] = T6b - T6e; + rio[WS(ios, 25)] = T8f - T8g; + rio[WS(ios, 9)] = T6b + T6e; + iio[-WS(ios, 9)] = T8f + T8g; + } + } + } + return W; +} + +static const tw_instr twinstr[] = { + {TW_COS, 0, 1}, + {TW_SIN, 0, 1}, + {TW_COS, 0, 3}, + {TW_SIN, 0, 3}, + {TW_COS, 0, 9}, + {TW_SIN, 0, 9}, + {TW_COS, 0, 27}, + {TW_SIN, 0, 27}, + {TW_NEXT, 1, 0} +}; + +static const hc2hc_desc desc = { 32, "hf2_32", twinstr, {376, 168, 112, 0}, &GENUS, 0, 0, 0 }; + +void X(codelet_hf2_32) (planner *p) { + X(khc2hc_dit_register) (p, hf2_32, &desc); +} diff --git a/src/fftw3/rdft/codelets/r2hc/hf2_4.c b/src/fftw3/rdft/codelets/r2hc/hf2_4.c new file mode 100644 index 0000000..a676143 --- /dev/null +++ b/src/fftw3/rdft/codelets/r2hc/hf2_4.c @@ -0,0 +1,108 @@ +/* + * 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 21:57:26 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_hc2hc -compact -variables 4 -twiddle-log3 -n 4 -dit -name hf2_4 -include hf.h */ + +/* + * This function contains 24 FP additions, 16 FP multiplications, + * (or, 16 additions, 8 multiplications, 8 fused multiply/add), + * 21 stack variables, and 16 memory accesses + */ +/* + * Generator Id's : + * $Id: hf2_4.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: hf2_4.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: hf2_4.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + */ + +#include "hf.h" + +static const R *hf2_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 + 4) { + E T1, Tp, Ta, Te, To, Tl, Tk, Th; + T1 = rio[0]; + Tp = iio[-WS(ios, 3)]; + { + E T7, Td, T9, Tc, Tg, Tf, T2, T4, T3, T5, T6, T8; + T7 = rio[WS(ios, 2)]; + Td = iio[-WS(ios, 2)]; + T9 = iio[-WS(ios, 1)]; + Tc = rio[WS(ios, 1)]; + Tg = iio[0]; + Tf = rio[WS(ios, 3)]; + T2 = W[2]; + T4 = W[3]; + T3 = W[0]; + T5 = W[1]; + T6 = FMA(T2, T3, T4 * T5); + T8 = FNMS(T4, T3, T2 * T5); + Ta = FNMS(T8, T9, T6 * T7); + Te = FMA(T3, Tc, T5 * Td); + To = FMA(T8, T7, T6 * T9); + Tl = FNMS(T4, Tf, T2 * Tg); + Tk = FNMS(T5, Tc, T3 * Td); + Th = FMA(T2, Tf, T4 * Tg); + } + { + E Tb, Ti, Tn, Tq; + Tb = T1 + Ta; + Ti = Te + Th; + iio[-WS(ios, 2)] = Tb - Ti; + rio[0] = Tb + Ti; + Tn = Tk + Tl; + Tq = To + Tp; + rio[WS(ios, 2)] = Tn - Tq; + iio[0] = Tn + Tq; + } + { + E Tj, Tm, Tr, Ts; + Tj = T1 - Ta; + Tm = Tk - Tl; + iio[-WS(ios, 3)] = Tj - Tm; + rio[WS(ios, 1)] = Tj + Tm; + Tr = Th - Te; + Ts = Tp - To; + rio[WS(ios, 3)] = Tr - Ts; + iio[-WS(ios, 1)] = Tr + Ts; + } + } + return W; +} + +static const tw_instr twinstr[] = { + {TW_COS, 0, 1}, + {TW_SIN, 0, 1}, + {TW_COS, 0, 3}, + {TW_SIN, 0, 3}, + {TW_NEXT, 1, 0} +}; + +static const hc2hc_desc desc = { 4, "hf2_4", twinstr, {16, 8, 8, 0}, &GENUS, 0, 0, 0 }; + +void X(codelet_hf2_4) (planner *p) { + X(khc2hc_dit_register) (p, hf2_4, &desc); +} diff --git a/src/fftw3/rdft/codelets/r2hc/hf2_64.c b/src/fftw3/rdft/codelets/r2hc/hf2_64.c new file mode 100644 index 0000000..fc2ec21 --- /dev/null +++ b/src/fftw3/rdft/codelets/r2hc/hf2_64.c @@ -0,0 +1,1906 @@ +/* + * 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 21:57:57 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_hc2hc -compact -variables 4 -twiddle-log3 -n 64 -dit -name hf2_64 -include hf.h */ + +/* + * This function contains 1154 FP additions, 660 FP multiplications, + * (or, 880 additions, 386 multiplications, 274 fused multiply/add), + * 382 stack variables, and 256 memory accesses + */ +/* + * Generator Id's : + * $Id: hf2_64.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: hf2_64.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: hf2_64.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + */ + +#include "hf.h" + +static const R *hf2_64(R *rio, R *iio, const R *W, stride ios, int m, int dist) +{ + DK(KP290284677, +0.290284677254462367636192375817395274691476278); + DK(KP956940335, +0.956940335732208864935797886980269969482849206); + DK(KP881921264, +0.881921264348355029712756863660388349508442621); + DK(KP471396736, +0.471396736825997648556387625905254377657460319); + DK(KP098017140, +0.098017140329560601994195563888641845861136673); + DK(KP995184726, +0.995184726672196886244836953109479921575474869); + DK(KP773010453, +0.773010453362736960810906609758469800971041293); + DK(KP634393284, +0.634393284163645498215171613225493370675687095); + DK(KP555570233, +0.555570233019602224742830813948532874374937191); + DK(KP831469612, +0.831469612302545237078788377617905756738560812); + DK(KP980785280, +0.980785280403230449126182236134239036973933731); + DK(KP195090322, +0.195090322016128267848284868477022240927691618); + DK(KP707106781, +0.707106781186547524400844362104849039284835938); + DK(KP923879532, +0.923879532511286756128183189396788286822416626); + DK(KP382683432, +0.382683432365089771728459984030398866761344562); + int i; + for (i = m - 2; i > 0; i = i - 2, rio = rio + dist, iio = iio - dist, W = W + 10) { + E T1, T1g, T91, T7W, T7m, T2O, T4j, T7P, T4P, T8y, T2w, T8t, T2Z, T8e, T48; + E T1z, T7s, T1I, T7t, T8p, Ten, T1Y, T7D, T2t, T7O, T7L, Te6, T3N, T8E, T7A; + E Te0, T4C, TeA, T8S, T9v, T65, Tfi, T9J, Taq, T6K, Tf6, Ta2, Ta5, T73, Tfc; + E Tad, Tag, T3z, T83, T3u, T82, T81, T84, T15, T9K, T68, T7j, T43, T9w, T4F; + E T8G, T5l, TeL, T9k, T9n, T6o, Tf2, T9Q, T9R, T6z, Tf3, T9T, T9W, To, Ts; + E T4o, T8u, T4U, T92, T5a, TeT, T8V, T8Y, T5G, TeG, T97, T9e, T27, T7X, T2T; + E T7E, T7b, Tai, T6T, Ta3, Tf7, Ta8, T7Q, T2H, T2c, T76, Tah, T7F, T4d, T8z; + E TG, TK, T69, T6b, T3b, T87, T5u, T9l, TeM, T9q, T88, T89, T3o, T86, T5P; + E T9f, TeH, T9a, T34, T8f, T1r, T7n, T3S, T8F, T4G, T4I, Tp, T6c, TH, T6a; + E TL, Ti1, T4H, T4J, Tt; + T1 = rio[0]; + { + E T12, T67, T14, T66, T6s, T1b, T1f, T6q, T1m, T6x, T1w, T1q, T6v, T6h, T31; + E T1D, T5I, T1y, T6g, T1S, T6m, T1N, T6W, T6Y, T1M, T6k, T1H, T2Y, T5L, T2W; + E T5N, T2b, T74, T2g, T29, T75, T26, T78, T1W, T22, T7a, T6R, T2u, T6P, T2v; + E T6L, T6M, T2E, T2G, T6I, T5Z, T2n, T63, T6G, T2r, T5H, T33, T5E, T2Q, T5z; + E T5C, T2S, T2M, T5q, T3a, T38, T5s, T2N, T5x, T5n, T3l, T5m, T3n, T5h, T5j; + E T3w, T3y, T58, T4a, T3t, T5d, T3r, T5e, T54, T4c, T4Z, T46, T4T, T4X, T47; + E T4l, T4N, T4i, T4g, T4O, T4n, T4R, T4E, T40, T4D, T42, T4y, T4A, T3J, T3L; + E T3R, T3G, T3E, T3P, T2i, Ta, Ty, Tf, Tw, T2, Tj, T3, Tc, T1E, T1B; + E T1F, T1A, T1R, T3x, T2m, T3K, T61, T1V, T60, T3I, T51, T52, T2V, T56, T5X; + E T3v, T55, T2X, T2q, T5W, T4w, T6E, Ta0, T8Q, Tac, T72, Tb, Tg, Th, T3e; + E T3f, T3h, T1a, T2x, T2B, TU, TV, TY, T1e, T2y, T2A, TC, TD, T1u, Tk; + E Tl, Tm, T39, T3U, T3W, T37, T3T, T3X, TQ, TR, TZ, T3c, T3d, T3i, Tx; + E Tz, T1t, TN, TX, T2f, T5V, Tao, T2h, T3D, T4f, T4h, T3F, T3q, T3s; + T12 = rio[WS(ios, 48)]; + T67 = iio[-WS(ios, 48)]; + T14 = iio[-WS(ios, 15)]; + T66 = rio[WS(ios, 15)]; + T6s = iio[-WS(ios, 8)]; + T1b = rio[WS(ios, 8)]; + T1f = iio[-WS(ios, 55)]; + T6q = rio[WS(ios, 55)]; + T1m = rio[WS(ios, 40)]; + T6x = iio[-WS(ios, 40)]; + T1w = rio[WS(ios, 56)]; + T1q = iio[-WS(ios, 23)]; + T6v = rio[WS(ios, 23)]; + T6h = iio[-WS(ios, 56)]; + T31 = rio[WS(ios, 50)]; + T1D = rio[WS(ios, 24)]; + T5I = iio[-WS(ios, 50)]; + T1y = iio[-WS(ios, 7)]; + T6g = rio[WS(ios, 7)]; + T1S = rio[WS(ios, 36)]; + T6m = iio[-WS(ios, 24)]; + T1N = iio[-WS(ios, 59)]; + T6W = rio[WS(ios, 59)]; + T6Y = iio[-WS(ios, 4)]; + T1M = rio[WS(ios, 4)]; + T6k = rio[WS(ios, 39)]; + T1H = iio[-WS(ios, 39)]; + T2Y = iio[-WS(ios, 45)]; + T5L = rio[WS(ios, 45)]; + T2W = rio[WS(ios, 18)]; + T5N = iio[-WS(ios, 18)]; + T2b = iio[-WS(ios, 11)]; + T74 = rio[WS(ios, 11)]; + T2g = rio[WS(ios, 60)]; + T29 = rio[WS(ios, 52)]; + T75 = iio[-WS(ios, 52)]; + T26 = iio[-WS(ios, 43)]; + T78 = rio[WS(ios, 43)]; + T1W = iio[-WS(ios, 27)]; + T22 = rio[WS(ios, 20)]; + T7a = iio[-WS(ios, 20)]; + T6R = iio[-WS(ios, 12)]; + T2u = rio[WS(ios, 12)]; + T6P = rio[WS(ios, 51)]; + T2v = iio[-WS(ios, 51)]; + T6L = rio[WS(ios, 19)]; + T6M = iio[-WS(ios, 44)]; + T2E = rio[WS(ios, 44)]; + T2G = iio[-WS(ios, 19)]; + T6I = iio[-WS(ios, 28)]; + T5Z = rio[WS(ios, 31)]; + T2n = rio[WS(ios, 28)]; + T63 = iio[-WS(ios, 32)]; + T6G = rio[WS(ios, 35)]; + T2r = iio[-WS(ios, 35)]; + T5H = rio[WS(ios, 13)]; + T33 = iio[-WS(ios, 13)]; + T5E = iio[-WS(ios, 34)]; + T2Q = rio[WS(ios, 34)]; + T5z = iio[-WS(ios, 2)]; + T5C = rio[WS(ios, 29)]; + T2S = iio[-WS(ios, 29)]; + T2M = rio[WS(ios, 2)]; + T5q = rio[WS(ios, 53)]; + T3a = iio[-WS(ios, 53)]; + T38 = rio[WS(ios, 10)]; + T5s = iio[-WS(ios, 10)]; + T2N = iio[-WS(ios, 61)]; + T5x = rio[WS(ios, 61)]; + T5n = iio[-WS(ios, 42)]; + T3l = rio[WS(ios, 42)]; + T5m = rio[WS(ios, 21)]; + T3n = iio[-WS(ios, 21)]; + T5h = rio[WS(ios, 37)]; + T5j = iio[-WS(ios, 26)]; + T3w = rio[WS(ios, 26)]; + T3y = iio[-WS(ios, 37)]; + T58 = iio[-WS(ios, 38)]; + T4a = rio[WS(ios, 38)]; + T3t = iio[-WS(ios, 5)]; + T5d = rio[WS(ios, 5)]; + T3r = rio[WS(ios, 58)]; + T5e = iio[-WS(ios, 58)]; + T54 = rio[WS(ios, 25)]; + T4c = iio[-WS(ios, 25)]; + T4Z = iio[-WS(ios, 6)]; + T46 = rio[WS(ios, 6)]; + T4T = iio[-WS(ios, 22)]; + T4X = rio[WS(ios, 57)]; + T47 = iio[-WS(ios, 57)]; + T4l = rio[WS(ios, 22)]; + T4N = rio[WS(ios, 9)]; + T4i = iio[-WS(ios, 9)]; + T4g = rio[WS(ios, 54)]; + T4O = iio[-WS(ios, 54)]; + T4n = iio[-WS(ios, 41)]; + T4R = rio[WS(ios, 41)]; + T4E = iio[-WS(ios, 46)]; + T40 = rio[WS(ios, 46)]; + T4D = rio[WS(ios, 17)]; + T42 = iio[-WS(ios, 17)]; + T4y = rio[WS(ios, 33)]; + T4A = iio[-WS(ios, 30)]; + T3J = rio[WS(ios, 30)]; + T3L = iio[-WS(ios, 33)]; + T3R = iio[-WS(ios, 49)]; + T3G = iio[-WS(ios, 1)]; + T3E = rio[WS(ios, 62)]; + T3P = rio[WS(ios, 14)]; + T2i = iio[-WS(ios, 3)]; + { + E T4u, T70, T71, T4v, T5T, T6C, T6D, T5U, T4, T7, T5, T8, TO, TP, T1U; + E T2p, T18, T2k, T2l, T2o, TT, TS, T19, T1c, T1T, T1P, T1Q, T1d; + T4u = rio[WS(ios, 1)]; + T70 = rio[WS(ios, 27)]; + T71 = iio[-WS(ios, 36)]; + T4v = iio[-WS(ios, 62)]; + T5T = rio[WS(ios, 63)]; + T6C = rio[WS(ios, 3)]; + T6D = iio[-WS(ios, 60)]; + T5U = iio[0]; + { + E T6, Te, T9, Td; + T4 = W[2]; + T7 = W[3]; + T5 = W[0]; + T8 = W[1]; + T6 = T4 * T5; + Te = T7 * T5; + T9 = T7 * T8; + Td = T4 * T8; + Ta = T6 - T9; + Ty = Td - Te; + Tf = Td + Te; + Tw = T6 + T9; + T2 = W[6]; + Tj = W[7]; + T3 = W[4]; + Tc = W[5]; + TO = T3 * T4; + TP = Tc * T7; + T1U = Tj * T3; + T2p = Tj * T5; + T18 = T3 * T5; + T2k = T2 * T5; + T2l = Tj * T8; + T2o = T2 * T8; + TT = Tc * T4; + TS = T3 * T7; + T19 = Tc * T8; + T1c = T3 * T8; + T1E = T2 * T7; + T1T = T2 * Tc; + T1B = Tj * T7; + T1F = Tj * T4; + T1P = T2 * T3; + T1Q = Tj * Tc; + T1A = T2 * T4; + T1d = Tc * T5; + } + T1R = T1P - T1Q; + T3x = T2o - T2p; + T2m = T2k - T2l; + T3K = T1E + T1F; + T61 = Tj * Ta; + T1V = T1T + T1U; + T60 = T2 * Tf; + T3I = T1A - T1B; + T51 = T2 * Tw; + T52 = Tj * Ty; + T2V = T1P + T1Q; + T56 = Tj * Tw; + T5X = Tj * Tf; + T3v = T2k + T2l; + T55 = T2 * Ty; + T2X = T1T - T1U; + T2q = T2o + T2p; + T5W = T2 * Ta; + T4w = FMA(T5, T4u, T8 * T4v); + T6E = FMA(T4, T6C, T7 * T6D); + Ta0 = FNMS(T7, T6C, T4 * T6D); + T8Q = FNMS(T8, T4u, T5 * T4v); + Tac = FNMS(Tj, T70, T2 * T71); + T72 = FMA(T2, T70, Tj * T71); + Tb = T3 * Ta; + Tg = Tc * Tf; + Th = Tb + Tg; + T3e = TS - TT; + T3f = Tj * T3e; + T3h = T2 * T3e; + T1a = T18 + T19; + T2x = T2 * T1a; + T2B = Tj * T1a; + TU = TS + TT; + TV = Tj * TU; + TY = T2 * TU; + T1e = T1c - T1d; + T2y = Tj * T1e; + T2A = T2 * T1e; + TC = T3 * Ty; + TD = Tc * Tw; + T1u = TC + TD; + Tk = T3 * Tf; + Tl = Tc * Ta; + Tm = Tk - Tl; + T39 = T1c + T1d; + T3U = Tj * T39; + T3W = T2 * T39; + T37 = T18 - T19; + T3T = T2 * T37; + T3X = Tj * T37; + TQ = TO - TP; + TR = T2 * TQ; + TZ = Tj * TQ; + T3c = TO + TP; + T3d = T2 * T3c; + T3i = Tj * T3c; + Tx = T3 * Tw; + Tz = Tc * Ty; + T1t = Tx - Tz; + TN = W[8]; + TX = W[9]; + T2f = FMA(TN, T4, TX * T7); + T5V = FMA(TN, T5T, TX * T5U); + Tao = FNMS(TX, T5T, TN * T5U); + T2h = FNMS(TX, T4, TN * T7); + T3D = FMA(TN, T5, TX * T8); + T4f = FMA(TN, T3, TX * Tc); + T4h = FNMS(TX, T3, TN * Tc); + T3F = FNMS(TX, T5, TN * T8); + } + T1g = FNMS(T1e, T1f, T1a * T1b); + T91 = FNMS(Tc, T4N, T3 * T4O); + T7W = FMA(Ty, T2M, Tw * T2N); + T7m = FMA(T1e, T1b, T1a * T1f); + T2O = FNMS(Ty, T2N, Tw * T2M); + T4j = FNMS(T4h, T4i, T4f * T4g); + T7P = FNMS(TU, T2u, TQ * T2v); + T4P = FMA(T3, T4N, Tc * T4O); + T8y = FMA(T3e, T46, T3c * T47); + T2w = FMA(TQ, T2u, TU * T2v); + { + E T1v, T1x, T1O, T1X; + T8t = FMA(T4h, T4g, T4f * T4i); + T2Z = FNMS(T2X, T2Y, T2V * T2W); + T8e = FMA(T2X, T2W, T2V * T2Y); + T48 = FNMS(T3e, T47, T3c * T46); + T1v = FMA(TN, T1t, TX * T1u); + T1x = FNMS(TX, T1t, TN * T1u); + T1z = FNMS(T1x, T1y, T1v * T1w); + T7s = FMA(T1x, T1w, T1v * T1y); + { + E T1C, T1G, T8n, T8o; + T1C = T1A + T1B; + T1G = T1E - T1F; + T1I = FNMS(T1G, T1H, T1C * T1D); + T7t = FMA(T1G, T1D, T1C * T1H); + T8n = FMA(T3F, T3E, T3D * T3G); + T8o = FNMS(T3K, T3J, T3I * T3L); + T8p = T8n - T8o; + Ten = T8n + T8o; + } + T1O = FMA(Ta, T1M, Tf * T1N); + T1X = FMA(T1R, T1S, T1V * T1W); + T1Y = T1O + T1X; + T7D = T1O - T1X; + { + E T2j, T2s, T7J, T7K; + T2j = FNMS(T2h, T2i, T2f * T2g); + T2s = FMA(T2m, T2n, T2q * T2r); + T2t = T2j + T2s; + T7O = T2j - T2s; + T7J = FMA(T2h, T2g, T2f * T2i); + T7K = FNMS(T2q, T2n, T2m * T2r); + T7L = T7J - T7K; + Te6 = T7J + T7K; + } + } + { + E T3H, T3M, T7y, T7z; + T3H = FNMS(T3F, T3G, T3D * T3E); + T3M = FMA(T3I, T3J, T3K * T3L); + T3N = T3H + T3M; + T8E = T3H - T3M; + T7y = FNMS(Tf, T1M, Ta * T1N); + T7z = FNMS(T1V, T1S, T1R * T1W); + T7A = T7y - T7z; + Te0 = T7y + T7z; + } + { + E T4B, T8R, T4x, T4z; + T4x = T3d + T3f; + T4z = T3h - T3i; + T4B = FNMS(T4z, T4A, T4x * T4y); + T8R = FMA(T4z, T4y, T4x * T4A); + T4C = T4w + T4B; + TeA = T8Q + T8R; + T8S = T8Q - T8R; + T9v = T4w - T4B; + } + { + E T64, Tap, T5Y, T62; + T5Y = T5W - T5X; + T62 = T60 + T61; + T64 = FMA(T5Y, T5Z, T62 * T63); + Tap = FNMS(T62, T5Z, T5Y * T63); + T65 = T5V + T64; + Tfi = Tao + Tap; + T9J = T5V - T64; + Taq = Tao - Tap; + } + { + E T6J, Ta1, T6F, T6H; + T6F = T2x + T2y; + T6H = T2A - T2B; + T6J = FNMS(T6H, T6I, T6F * T6G); + Ta1 = FMA(T6H, T6G, T6F * T6I); + T6K = T6E + T6J; + Tf6 = Ta0 + Ta1; + Ta2 = Ta0 - Ta1; + Ta5 = T6E - T6J; + } + { + E T6Z, Tab, T6V, T6X; + T6V = FMA(TN, Ta, TX * Tf); + T6X = FNMS(TX, Ta, TN * Tf); + T6Z = FNMS(T6X, T6Y, T6V * T6W); + Tab = FMA(T6X, T6W, T6V * T6Y); + T73 = T6Z + T72; + Tfc = Tab + Tac; + Tad = Tab - Tac; + Tag = T6Z - T72; + } + T3z = FNMS(T3x, T3y, T3v * T3w); + T83 = FMA(T3x, T3w, T3v * T3y); + T3q = FNMS(TX, Tm, TN * Th); + T3s = FMA(TN, Tm, TX * Th); + T3u = FMA(T3q, T3r, T3s * T3t); + T82 = FNMS(T3s, T3r, T3q * T3t); + T81 = T3u - T3z; + T84 = T82 - T83; + { + E TW, T10, T11, T13; + TW = TR + TV; + T10 = TY - TZ; + T11 = FNMS(TX, T10, TN * TW); + T13 = FMA(TN, T10, TX * TW); + T15 = FMA(T11, T12, T13 * T14); + T9K = FMA(T10, T66, TW * T67); + T68 = FNMS(T10, T67, TW * T66); + T7j = FNMS(T13, T12, T11 * T14); + } + { + E T3V, T3Y, T3Z, T41; + T3V = T3T + T3U; + T3Y = T3W - T3X; + T3Z = FNMS(TX, T3Y, TN * T3V); + T41 = FMA(TN, T3Y, TX * T3V); + T43 = FMA(T3Z, T40, T41 * T42); + T9w = FMA(T3Y, T4D, T3V * T4E); + T4F = FNMS(T3Y, T4E, T3V * T4D); + T8G = FNMS(T41, T40, T3Z * T42); + } + { + E T5f, T9i, T5k, T9j, T5g, T5i; + T5f = FNMS(Tm, T5e, Th * T5d); + T9i = FMA(Tm, T5d, Th * T5e); + T5g = T3T - T3U; + T5i = T3W + T3X; + T5k = FMA(T5g, T5h, T5i * T5j); + T9j = FNMS(T5i, T5h, T5g * T5j); + T5l = T5f + T5k; + TeL = T9i + T9j; + T9k = T9i - T9j; + T9n = T5f - T5k; + } + { + E T6i, T9O, T6n, T9P, T6j, T6l; + T6i = FMA(T1t, T6g, T1u * T6h); + T9O = FNMS(T1u, T6g, T1t * T6h); + T6j = TR - TV; + T6l = TY + TZ; + T6n = FMA(T6j, T6k, T6l * T6m); + T9P = FNMS(T6l, T6k, T6j * T6m); + T6o = T6i + T6n; + Tf2 = T9O + T9P; + T9Q = T9O - T9P; + T9R = T6i - T6n; + } + { + E T6t, T9U, T6y, T9V; + { + E T6p, T6r, T6u, T6w; + T6p = FNMS(TX, T1e, TN * T1a); + T6r = FMA(TN, T1e, TX * T1a); + T6t = FMA(T6p, T6q, T6r * T6s); + T9U = FNMS(T6r, T6q, T6p * T6s); + T6u = T5W + T5X; + T6w = T60 - T61; + T6y = FNMS(T6w, T6x, T6u * T6v); + T9V = FMA(T6w, T6v, T6u * T6x); + } + T6z = T6t + T6y; + Tf3 = T9U + T9V; + T9T = T6t - T6y; + T9W = T9U - T9V; + } + { + E Ti, Tn, T4k, Tq, Tr, T4m, T4Q, T4S; + Ti = T2 * Th; + Tn = Tj * Tm; + T4k = Ti - Tn; + Tq = T2 * Tm; + Tr = Tj * Th; + T4m = Tq + Tr; + To = Ti + Tn; + Ts = Tq - Tr; + T4o = FMA(T4k, T4l, T4m * T4n); + T8u = FNMS(T4m, T4l, T4k * T4n); + T4Q = FMA(TN, T4k, TX * T4m); + T4S = FNMS(TX, T4k, TN * T4m); + T4U = FNMS(T4S, T4T, T4Q * T4R); + T92 = FMA(T4S, T4R, T4Q * T4T); + } + { + E T50, T8W, T59, T8X; + { + E T4W, T4Y, T53, T57; + T4W = FNMS(TX, T3e, TN * T3c); + T4Y = FMA(TN, T3e, TX * T3c); + T50 = FMA(T4W, T4X, T4Y * T4Z); + T8W = FNMS(T4Y, T4X, T4W * T4Z); + T53 = T51 - T52; + T57 = T55 + T56; + T59 = FMA(T53, T54, T57 * T58); + T8X = FNMS(T57, T54, T53 * T58); + } + T5a = T50 + T59; + TeT = T8W + T8X; + T8V = T50 - T59; + T8Y = T8W - T8X; + } + { + E T5A, T9c, T5F, T9d; + { + E T5w, T5y, T5B, T5D; + T5w = FNMS(TX, Ty, TN * Tw); + T5y = FMA(TN, Ty, TX * Tw); + T5A = FMA(T5w, T5x, T5y * T5z); + T9c = FNMS(T5y, T5x, T5w * T5z); + T5B = T51 + T52; + T5D = T55 - T56; + T5F = FNMS(T5D, T5E, T5B * T5C); + T9d = FMA(T5D, T5C, T5B * T5E); + } + T5G = T5A + T5F; + TeG = T9c + T9d; + T97 = T5A - T5F; + T9e = T9c - T9d; + } + { + E T21, T2P, T25, T2R, T77, T79; + { + E T1Z, T20, T23, T24; + T1Z = T2 * T1t; + T20 = Tj * T1u; + T21 = T1Z + T20; + T2P = T1Z - T20; + T23 = T2 * T1u; + T24 = Tj * T1t; + T25 = T23 - T24; + T2R = T23 + T24; + } + T27 = FNMS(T25, T26, T21 * T22); + T7X = FNMS(T2R, T2Q, T2P * T2S); + T2T = FMA(T2P, T2Q, T2R * T2S); + T7E = FMA(T25, T22, T21 * T26); + T77 = FNMS(TX, T25, TN * T21); + T79 = FMA(TN, T25, TX * T21); + T7b = FMA(T77, T78, T79 * T7a); + Tai = FNMS(T79, T78, T77 * T7a); + } + { + E T6S, Ta7, T2D, Ta6, T2F, T6N; + { + E T6O, T6Q, T2z, T2C; + T6O = FMA(TN, TQ, TX * TU); + T6Q = FNMS(TX, TQ, TN * TU); + T6S = FNMS(T6Q, T6R, T6O * T6P); + Ta7 = FMA(T6Q, T6P, T6O * T6R); + T2z = T2x - T2y; + T2C = T2A + T2B; + T2D = FMA(TN, T2z, TX * T2C); + Ta6 = FNMS(T2C, T6L, T2z * T6M); + T2F = FNMS(TX, T2z, TN * T2C); + T6N = FMA(T2z, T6L, T2C * T6M); + } + T6T = T6N + T6S; + Ta3 = T6N - T6S; + Tf7 = Ta6 + Ta7; + Ta8 = Ta6 - Ta7; + T7Q = FMA(T2F, T2E, T2D * T2G); + T2H = FNMS(T2F, T2G, T2D * T2E); + } + { + E TA, TE, TB, TF, TJ, TI, T2a, T28, T49, T4b; + TA = Tx + Tz; + TE = TC - TD; + TB = T2 * TA; + TF = Tj * TE; + TJ = Tj * TA; + TI = T2 * TE; + T2a = FMA(TN, TE, TX * TA); + T28 = FNMS(TX, TE, TN * TA); + T2c = FMA(T28, T29, T2a * T2b); + T76 = FNMS(TE, T75, TA * T74); + Tah = FMA(TE, T74, TA * T75); + T7F = FNMS(T2a, T29, T28 * T2b); + T49 = TB + TF; + T4b = TI - TJ; + T4d = FNMS(T4b, T4c, T49 * T4a); + T8z = FMA(T4b, T4a, T49 * T4c); + TG = TB - TF; + TK = TI + TJ; + T69 = FMA(TN, TG, TX * TK); + T6b = FNMS(TX, TG, TN * TK); + } + { + E T5t, T9p, T3k, T9o, T3m, T5o; + T3b = FMA(T37, T38, T39 * T3a); + T87 = FNMS(T39, T38, T37 * T3a); + { + E T5p, T5r, T3g, T3j; + T5p = FMA(TN, T37, TX * T39); + T5r = FNMS(TX, T37, TN * T39); + T5t = FNMS(T5r, T5s, T5p * T5q); + T9p = FMA(T5r, T5q, T5p * T5s); + T3g = T3d - T3f; + T3j = T3h + T3i; + T3k = FMA(TN, T3g, TX * T3j); + T9o = FNMS(T3j, T5m, T3g * T5n); + T3m = FNMS(TX, T3g, TN * T3j); + T5o = FMA(T3g, T5m, T3j * T5n); + } + T5u = T5o + T5t; + T9l = T5o - T5t; + TeM = T9o + T9p; + T9q = T9o - T9p; + T88 = FMA(T3m, T3l, T3k * T3n); + T89 = T87 - T88; + T3o = FNMS(T3m, T3n, T3k * T3l); + T86 = T3b - T3o; + } + { + E T5O, T99, T1i, T1n, T1o, T1k, T30, T5J, T98, T32; + { + E T5K, T5M, T1h, T1j; + T5K = FNMS(TX, T2X, TN * T2V); + T5M = FMA(TN, T2X, TX * T2V); + T5O = FMA(T5K, T5L, T5M * T5N); + T99 = FNMS(T5M, T5L, T5K * T5N); + T1h = Tb - Tg; + T1j = Tk + Tl; + T1i = T2 * T1h; + T1n = T2 * T1j; + T1o = Tj * T1h; + T1k = Tj * T1j; + T30 = FMA(TN, T1h, TX * T1j); + T5J = FMA(T1h, T5H, T1j * T5I); + T98 = FNMS(T1j, T5H, T1h * T5I); + T32 = FNMS(TX, T1h, TN * T1j); + } + T5P = T5J + T5O; + T9f = T5J - T5O; + TeH = T98 + T99; + T9a = T98 - T99; + T34 = FNMS(T32, T33, T30 * T31); + T8f = FMA(T32, T31, T30 * T33); + { + E T1l, T1p, T3O, T3Q; + T1l = T1i - T1k; + T1p = T1n + T1o; + T1r = FMA(T1l, T1m, T1p * T1q); + T7n = FNMS(T1p, T1m, T1l * T1q); + T3O = T1i + T1k; + T3Q = T1n - T1o; + T3S = FNMS(T3Q, T3R, T3O * T3P); + T8F = FMA(T3Q, T3P, T3O * T3R); + T4G = FNMS(TX, T3Q, TN * T3O); + T4I = FMA(TN, T3Q, TX * T3O); + } + } + } + Tp = rio[WS(ios, 32)]; + T6c = iio[-WS(ios, 16)]; + TH = rio[WS(ios, 16)]; + T6a = rio[WS(ios, 47)]; + TL = iio[-WS(ios, 47)]; + Ti1 = iio[-WS(ios, 63)]; + T4H = rio[WS(ios, 49)]; + T4J = iio[-WS(ios, 14)]; + Tt = iio[-WS(ios, 31)]; + { + E T5R, TgT, TgY, ThE, T9t, Tbe, T9G, Tbb, Tcl, Tdq, Tcs, Tdn, TeP, Tg4, TeY; + E Tg1, T7e, Th4, ThJ, Th9, Tfp, Tg8, Tfg, Tgb, T2K, TgC, Tih, ThX, TfQ, TiL; + E Tea, Tiv, Tam, Tbl, TcL, Tdu, Taz, Tbi, TcE, Tdx, T7U, Tjv, Tdc, Tjh, Tb0; + E TjL, TbU, TiZ, T8D, Tb5, Tc8, Tdi, T8M, Tb6, Tc5, Tdh, T4r, Thz, Tex, Tfz; + E TfX, Tgl, TgN, Thj, T8m, TaI, Tdg, TdG, Tb4, Tbu, Tc2, TcU, T3C, Thy, Tem; + E Tfy, TfU, Tgk, TgI, Thi, T6B, Th1, Tfm, Tga, Th8, ThI, T9Z, Tbh, Taw, Tbk; + E TcI, Tdw, Tf5, Tg7, Tcx, Tdt, T5c, TgV, TeV, Tg0, TgS, ThD, TeE, Tg3, T96; + E Tbd, Tce, Tdp, Tcp, Tdm, T9D, Tba, T1L, Tgz, Ti4, Tii, Tiy, TiM, TdZ, TfN; + E T7x, TaX, Tj4, Tji, Tjy, TjM, TbN, Td9; + { + E T5v, T5Q, TgW, TgX; + T5v = T5l + T5u; + T5Q = T5G + T5P; + T5R = T5v + T5Q; + TgT = T5Q - T5v; + TgW = TeL + TeM; + TgX = TeG + TeH; + TgY = TgW - TgX; + ThE = TgW + TgX; + } + { + E T9h, T9F, T9s, T9E; + { + E T9b, T9g, T9m, T9r; + T9b = T97 - T9a; + T9g = T9e + T9f; + T9h = FNMS(KP923879532, T9g, KP382683432 * T9b); + T9F = FMA(KP382683432, T9g, KP923879532 * T9b); + T9m = T9k + T9l; + T9r = T9n - T9q; + T9s = FMA(KP923879532, T9m, KP382683432 * T9r); + T9E = FNMS(KP923879532, T9r, KP382683432 * T9m); + } + T9t = T9h - T9s; + Tbe = T9E + T9F; + T9G = T9E - T9F; + Tbb = T9s + T9h; + } + { + E Tch, Tcr, Tck, Tcq; + { + E Tcf, Tcg, Tci, Tcj; + Tcf = T97 + T9a; + Tcg = T9e - T9f; + Tch = FNMS(KP382683432, Tcg, KP923879532 * Tcf); + Tcr = FMA(KP923879532, Tcg, KP382683432 * Tcf); + Tci = T9k - T9l; + Tcj = T9n + T9q; + Tck = FMA(KP382683432, Tci, KP923879532 * Tcj); + Tcq = FNMS(KP382683432, Tcj, KP923879532 * Tci); + } + Tcl = Tch - Tck; + Tdq = Tcq + Tcr; + Tcs = Tcq - Tcr; + Tdn = Tck + Tch; + } + { + E TeJ, TeX, TeO, TeW; + { + E TeF, TeI, TeK, TeN; + TeF = T5G - T5P; + TeI = TeG - TeH; + TeJ = TeF - TeI; + TeX = TeF + TeI; + TeK = T5l - T5u; + TeN = TeL - TeM; + TeO = TeK + TeN; + TeW = TeN - TeK; + } + TeP = KP707106781 * (TeJ - TeO); + Tg4 = KP707106781 * (TeW + TeX); + TeY = KP707106781 * (TeW - TeX); + Tg1 = KP707106781 * (TeO + TeJ); + } + { + E T6U, Th2, T7d, Tfb, Tfe, Th3, Tfa, Tfo, Tfn, Tff; + T6U = T6K + T6T; + Th2 = Tf6 + Tf7; + { + E T7c, Tfd, Tf8, Tf9; + T7c = T76 + T7b; + T7d = T73 + T7c; + Tfb = T73 - T7c; + Tfd = Tah + Tai; + Tfe = Tfc - Tfd; + Th3 = Tfc + Tfd; + Tf8 = Tf6 - Tf7; + Tf9 = T6K - T6T; + Tfa = Tf8 - Tf9; + Tfo = Tf9 + Tf8; + } + T7e = T6U + T7d; + Th4 = Th2 - Th3; + ThJ = Th2 + Th3; + Th9 = T7d - T6U; + Tfn = Tfb - Tfe; + Tfp = KP707106781 * (Tfn - Tfo); + Tg8 = KP707106781 * (Tfo + Tfn); + Tff = Tfb + Tfe; + Tfg = KP707106781 * (Tfa - Tff); + Tgb = KP707106781 * (Tfa + Tff); + } + { + E T2e, Te3, Te8, TgB, T2J, Te5, Te2, TgA; + { + E T2d, Te7, T2I, Te1; + T2d = T27 + T2c; + T2e = T1Y + T2d; + Te3 = T1Y - T2d; + Te7 = T7P + T7Q; + Te8 = Te6 - Te7; + TgB = Te6 + Te7; + T2I = T2w + T2H; + T2J = T2t + T2I; + Te5 = T2t - T2I; + Te1 = T7E + T7F; + Te2 = Te0 - Te1; + TgA = Te0 + Te1; + } + T2K = T2e + T2J; + TgC = TgA - TgB; + Tih = T2J - T2e; + ThX = TgA + TgB; + { + E TfO, TfP, Te4, Te9; + TfO = Te3 + Te2; + TfP = Te5 - Te8; + TfQ = KP707106781 * (TfO + TfP); + TiL = KP707106781 * (TfP - TfO); + Te4 = Te2 - Te3; + Te9 = Te5 + Te8; + Tea = KP707106781 * (Te4 - Te9); + Tiv = KP707106781 * (Te4 + Te9); + } + } + { + E Taf, TcB, Tak, TcC, Taa, Tay, TcA, TcK, Tae, Taj; + Tae = T76 - T7b; + Taf = Tad + Tae; + TcB = Tad - Tae; + Taj = Tah - Tai; + Tak = Tag - Taj; + TcC = Tag + Taj; + { + E Ta4, Ta9, Tcy, Tcz; + Ta4 = Ta2 + Ta3; + Ta9 = Ta5 - Ta8; + Taa = FNMS(KP923879532, Ta9, KP382683432 * Ta4); + Tay = FMA(KP923879532, Ta4, KP382683432 * Ta9); + Tcy = Ta2 - Ta3; + Tcz = Ta5 + Ta8; + TcA = FNMS(KP382683432, Tcz, KP923879532 * Tcy); + TcK = FMA(KP382683432, Tcy, KP923879532 * Tcz); + } + { + E Tal, TcJ, Tax, TcD; + Tal = FMA(KP382683432, Taf, KP923879532 * Tak); + Tam = Taa - Tal; + Tbl = Taa + Tal; + TcJ = FNMS(KP382683432, TcB, KP923879532 * TcC); + TcL = TcJ - TcK; + Tdu = TcK + TcJ; + Tax = FNMS(KP923879532, Taf, KP382683432 * Tak); + Taz = Tax - Tay; + Tbi = Tay + Tax; + TcD = FMA(KP923879532, TcB, KP382683432 * TcC); + TcE = TcA - TcD; + Tdx = TcA + TcD; + } + } + { + E T7C, TbO, T7S, TbS, T7H, TbP, T7N, TbR; + { + E T7B, T7R, T7G, T7M; + T7B = T27 - T2c; + T7C = T7A + T7B; + TbO = T7A - T7B; + T7R = T7P - T7Q; + T7S = T7O - T7R; + TbS = T7O + T7R; + T7G = T7E - T7F; + T7H = T7D - T7G; + TbP = T7D + T7G; + T7M = T2w - T2H; + T7N = T7L + T7M; + TbR = T7L - T7M; + } + { + E T7I, T7T, Tda, Tdb; + T7I = FNMS(KP923879532, T7H, KP382683432 * T7C); + T7T = FMA(KP382683432, T7N, KP923879532 * T7S); + T7U = T7I - T7T; + Tjv = T7I + T7T; + Tda = FMA(KP382683432, TbO, KP923879532 * TbP); + Tdb = FNMS(KP382683432, TbR, KP923879532 * TbS); + Tdc = Tda + Tdb; + Tjh = Tdb - Tda; + } + { + E TaY, TaZ, TbQ, TbT; + TaY = FMA(KP923879532, T7C, KP382683432 * T7H); + TaZ = FNMS(KP923879532, T7N, KP382683432 * T7S); + Tb0 = TaY + TaZ; + TjL = TaZ - TaY; + TbQ = FNMS(KP382683432, TbP, KP923879532 * TbO); + TbT = FMA(KP923879532, TbR, KP382683432 * TbS); + TbU = TbQ - TbT; + TiZ = TbQ + TbT; + } + } + { + E T8r, Tc6, T8I, Tc3, T8w, T8K, T8B, T8J, T8q, T8H; + T8q = T3S - T43; + T8r = T8p + T8q; + Tc6 = T8p - T8q; + T8H = T8F - T8G; + T8I = T8E - T8H; + Tc3 = T8E + T8H; + { + E T8s, T8v, T8x, T8A; + T8s = T4j - T4o; + T8v = T8t - T8u; + T8w = T8s - T8v; + T8K = T8s + T8v; + T8x = T48 - T4d; + T8A = T8y - T8z; + T8B = T8x + T8A; + T8J = T8A - T8x; + } + { + E T8C, Tc7, T8L, Tc4; + T8C = KP707106781 * (T8w - T8B); + T8D = T8r - T8C; + Tb5 = T8r + T8C; + Tc7 = KP707106781 * (T8J + T8K); + Tc8 = Tc6 - Tc7; + Tdi = Tc6 + Tc7; + T8L = KP707106781 * (T8J - T8K); + T8M = T8I - T8L; + Tb6 = T8I + T8L; + Tc4 = KP707106781 * (T8B + T8w); + Tc5 = Tc3 - Tc4; + Tdh = Tc3 + Tc4; + } + } + { + E T45, Tes, Tep, TgK, T4q, Teq, Tev, TgL, T44, Teo, Ter, Tew; + T44 = T3S + T43; + T45 = T3N + T44; + Tes = T3N - T44; + Teo = T8F + T8G; + Tep = Ten - Teo; + TgK = Ten + Teo; + { + E T4e, T4p, Tet, Teu; + T4e = T48 + T4d; + T4p = T4j + T4o; + T4q = T4e + T4p; + Teq = T4p - T4e; + Tet = T8y + T8z; + Teu = T8t + T8u; + Tev = Tet - Teu; + TgL = Tet + Teu; + } + T4r = T45 + T4q; + Thz = TgK + TgL; + Ter = Tep - Teq; + Tew = Tes - Tev; + Tex = FMA(KP382683432, Ter, KP923879532 * Tew); + Tfz = FNMS(KP923879532, Ter, KP382683432 * Tew); + { + E TfV, TfW, TgJ, TgM; + TfV = Tep + Teq; + TfW = Tes + Tev; + TfX = FMA(KP923879532, TfV, KP382683432 * TfW); + Tgl = FNMS(KP382683432, TfV, KP923879532 * TfW); + TgJ = T45 - T4q; + TgM = TgK - TgL; + TgN = TgJ + TgM; + Thj = TgJ - TgM; + } + } + { + E T80, TbW, T8k, TbX, T8b, Tc0, T8h, TbZ; + { + E T7Y, T7Z, T8i, T8j; + T7Y = T7W - T7X; + T7Z = T2Z - T34; + T80 = T7Y + T7Z; + TbW = T7Y - T7Z; + T8i = T89 - T86; + T8j = T81 + T84; + T8k = KP707106781 * (T8i - T8j); + TbX = KP707106781 * (T8i + T8j); + } + { + E T85, T8a, T8d, T8g; + T85 = T81 - T84; + T8a = T86 + T89; + T8b = KP707106781 * (T85 - T8a); + Tc0 = KP707106781 * (T8a + T85); + T8d = T2O - T2T; + T8g = T8e - T8f; + T8h = T8d - T8g; + TbZ = T8d + T8g; + } + { + E T8c, T8l, Tde, Tdf; + T8c = T80 - T8b; + T8l = T8h - T8k; + T8m = FNMS(KP980785280, T8l, KP195090322 * T8c); + TaI = FMA(KP980785280, T8c, KP195090322 * T8l); + Tde = TbW + TbX; + Tdf = TbZ + Tc0; + Tdg = FNMS(KP195090322, Tdf, KP980785280 * Tde); + TdG = FMA(KP980785280, Tdf, KP195090322 * Tde); + } + { + E Tb2, Tb3, TbY, Tc1; + Tb2 = T80 + T8b; + Tb3 = T8h + T8k; + Tb4 = FNMS(KP555570233, Tb3, KP831469612 * Tb2); + Tbu = FMA(KP555570233, Tb2, KP831469612 * Tb3); + TbY = TbW - TbX; + Tc1 = TbZ - Tc0; + Tc2 = FNMS(KP831469612, Tc1, KP555570233 * TbY); + TcU = FMA(KP555570233, Tc1, KP831469612 * TbY); + } + } + { + E T36, Teh, Tek, TgF, T3B, Tef, Tee, TgE, Teg, Tel; + { + E T2U, T35, Tei, Tej; + T2U = T2O + T2T; + T35 = T2Z + T34; + T36 = T2U + T35; + Teh = T2U - T35; + Tei = T87 + T88; + Tej = T82 + T83; + Tek = Tei - Tej; + TgF = Tei + Tej; + } + { + E T3p, T3A, Tec, Ted; + T3p = T3b + T3o; + T3A = T3u + T3z; + T3B = T3p + T3A; + Tef = T3A - T3p; + Tec = T7W + T7X; + Ted = T8e + T8f; + Tee = Tec - Ted; + TgE = Tec + Ted; + } + T3C = T36 + T3B; + Thy = TgE + TgF; + Teg = Tee - Tef; + Tel = Teh - Tek; + Tem = FNMS(KP923879532, Tel, KP382683432 * Teg); + Tfy = FMA(KP923879532, Teg, KP382683432 * Tel); + { + E TfS, TfT, TgG, TgH; + TfS = Tee + Tef; + TfT = Teh + Tek; + TfU = FNMS(KP382683432, TfT, KP923879532 * TfS); + Tgk = FMA(KP382683432, TfS, KP923879532 * TfT); + TgG = TgE - TgF; + TgH = T36 - T3B; + TgI = TgG - TgH; + Thi = TgH + TgG; + } + } + { + E T6A, Tfl, Th7, Tf4, T6e, Tar, T9Y, TcH, Tav, Tcw, T9M, Tfj; + T6A = T6o + T6z; + Tfl = T6z - T6o; + Th7 = Tf2 + Tf3; + Tf4 = Tf2 - Tf3; + { + E T6d, T9S, T9X, Tat, Tau, T9L; + T6d = FNMS(T6b, T6c, T69 * T6a); + T6e = T68 + T6d; + Tar = T68 - T6d; + T9S = T9Q - T9R; + T9X = T9T + T9W; + T9Y = KP707106781 * (T9S - T9X); + TcH = KP707106781 * (T9S + T9X); + Tat = T9T - T9W; + Tau = T9R + T9Q; + Tav = KP707106781 * (Tat - Tau); + Tcw = KP707106781 * (Tau + Tat); + T9L = FMA(T6b, T6a, T69 * T6c); + T9M = T9K - T9L; + Tfj = T9K + T9L; + } + { + E T6f, Tfk, Th6, T9N; + T6f = T65 + T6e; + T6B = T6f + T6A; + Th1 = T6f - T6A; + Tfk = Tfi - Tfj; + Tfm = Tfk - Tfl; + Tga = Tfk + Tfl; + Th6 = Tfi + Tfj; + Th8 = Th6 - Th7; + ThI = Th6 + Th7; + T9N = T9J - T9M; + T9Z = T9N - T9Y; + Tbh = T9N + T9Y; + } + { + E Tas, TcG, Tf1, Tcv; + Tas = Taq + Tar; + Taw = Tas - Tav; + Tbk = Tas + Tav; + TcG = Taq - Tar; + TcI = TcG - TcH; + Tdw = TcG + TcH; + Tf1 = T65 - T6e; + Tf5 = Tf1 - Tf4; + Tg7 = Tf1 + Tf4; + Tcv = T9J + T9M; + Tcx = Tcv - Tcw; + Tdt = Tcv + Tcw; + } + } + { + E T8Z, T9B, T5b, TeD, TeU, TgR, T94, T9A, T4L, T8T, T9y, TeB, T4V; + T8Z = T8V - T8Y; + T9B = T8V + T8Y; + T4V = T4P + T4U; + T5b = T4V + T5a; + TeD = T5a - T4V; + { + E TeS, T90, T93, T4K, T9x; + TeS = T91 + T92; + TeU = TeS - TeT; + TgR = TeS + TeT; + T90 = T4P - T4U; + T93 = T91 - T92; + T94 = T90 + T93; + T9A = T93 - T90; + T4K = FMA(T4G, T4H, T4I * T4J); + T4L = T4F + T4K; + T8T = T4F - T4K; + T9x = FNMS(T4I, T4H, T4G * T4J); + T9y = T9w - T9x; + TeB = T9w + T9x; + } + { + E T4M, TeR, TgQ, TeC; + T4M = T4C + T4L; + T5c = T4M + T5b; + TgV = T4M - T5b; + TeR = T4C - T4L; + TeV = TeR - TeU; + Tg0 = TeR + TeU; + TgQ = TeA + TeB; + TgS = TgQ - TgR; + ThD = TgQ + TgR; + TeC = TeA - TeB; + TeE = TeC - TeD; + Tg3 = TeC + TeD; + } + { + E T8U, T95, Tcc, Tcd; + T8U = T8S + T8T; + T95 = KP707106781 * (T8Z - T94); + T96 = T8U - T95; + Tbd = T8U + T95; + Tcc = T8S - T8T; + Tcd = KP707106781 * (T9A + T9B); + Tce = Tcc - Tcd; + Tdp = Tcc + Tcd; + } + { + E Tcn, Tco, T9z, T9C; + Tcn = T9v + T9y; + Tco = KP707106781 * (T94 + T8Z); + Tcp = Tcn - Tco; + Tdm = Tcn + Tco; + T9z = T9v - T9y; + T9C = KP707106781 * (T9A - T9B); + T9D = T9z - T9C; + Tba = T9z + T9C; + } + } + { + E Tv, T7h, TdY, ThY, Ti2, Tj1, T16, Tj2, T1K, Tiw, T7q, TbK, T7v, TbL, T7k; + E ThZ, T7r, T7u, T7i; + { + E Tu, TdW, TdX, Ti0, TM; + Tu = FNMS(Ts, Tt, To * Tp); + Tv = T1 + Tu; + T7h = T1 - Tu; + TdW = T7m + T7n; + TdX = T7s + T7t; + TdY = TdW - TdX; + ThY = TdW + TdX; + Ti0 = FMA(Ts, Tp, To * Tt); + Ti2 = Ti0 + Ti1; + Tj1 = Ti1 - Ti0; + TM = FMA(TG, TH, TK * TL); + T16 = TM + T15; + Tj2 = TM - T15; + } + { + E T1s, T1J, T7o, T7p; + T1s = T1g + T1r; + T1J = T1z + T1I; + T1K = T1s + T1J; + Tiw = T1J - T1s; + T7o = T7m - T7n; + T7p = T1g - T1r; + T7q = T7o - T7p; + TbK = T7p + T7o; + } + T7r = T1z - T1I; + T7u = T7s - T7t; + T7v = T7r + T7u; + TbL = T7r - T7u; + T7i = FNMS(TK, TH, TG * TL); + T7k = T7i - T7j; + ThZ = T7i + T7j; + { + E T17, Ti3, Tix, TdV; + T17 = Tv + T16; + T1L = T17 + T1K; + Tgz = T17 - T1K; + Ti3 = ThZ + Ti2; + Ti4 = ThY + Ti3; + Tii = Ti3 - ThY; + Tix = Ti2 - ThZ; + Tiy = Tiw + Tix; + TiM = Tix - Tiw; + TdV = Tv - T16; + TdZ = TdV - TdY; + TfN = TdV + TdY; + } + { + E T7l, T7w, Tj0, Tj3; + T7l = T7h - T7k; + T7w = KP707106781 * (T7q - T7v); + T7x = T7l - T7w; + TaX = T7l + T7w; + Tj0 = KP707106781 * (T7q + T7v); + Tj3 = Tj1 - Tj2; + Tj4 = Tj0 + Tj3; + Tji = Tj3 - Tj0; + } + { + E Tjw, Tjx, TbJ, TbM; + Tjw = KP707106781 * (TbL - TbK); + Tjx = Tj2 + Tj1; + Tjy = Tjw + Tjx; + TjM = Tjx - Tjw; + TbJ = T7h + T7k; + TbM = KP707106781 * (TbK + TbL); + TbN = TbJ - TbM; + Td9 = TbJ + TbM; + } + } + { + E T4t, ThR, Ti6, Ti8, T7g, Ti7, ThU, ThV; + { + E T2L, T4s, ThW, Ti5; + T2L = T1L + T2K; + T4s = T3C + T4r; + T4t = T2L + T4s; + ThR = T2L - T4s; + ThW = Thy + Thz; + Ti5 = ThX + Ti4; + Ti6 = ThW + Ti5; + Ti8 = Ti5 - ThW; + } + { + E T5S, T7f, ThS, ThT; + T5S = T5c + T5R; + T7f = T6B + T7e; + T7g = T5S + T7f; + Ti7 = T7f - T5S; + ThS = ThD + ThE; + ThT = ThI + ThJ; + ThU = ThS - ThT; + ThV = ThS + ThT; + } + iio[-WS(ios, 32)] = T4t - T7g; + rio[WS(ios, 32)] = ThV - Ti6; + rio[0] = T4t + T7g; + iio[0] = ThV + Ti6; + iio[-WS(ios, 48)] = ThR - ThU; + rio[WS(ios, 48)] = Ti7 - Ti8; + rio[WS(ios, 16)] = ThR + ThU; + iio[-WS(ios, 16)] = Ti7 + Ti8; + } + { + E ThB, ThN, Tic, Tie, ThG, ThO, ThL, ThP; + { + E Thx, ThA, Tia, Tib; + Thx = T1L - T2K; + ThA = Thy - Thz; + ThB = Thx + ThA; + ThN = Thx - ThA; + Tia = T4r - T3C; + Tib = Ti4 - ThX; + Tic = Tia + Tib; + Tie = Tib - Tia; + } + { + E ThC, ThF, ThH, ThK; + ThC = T5c - T5R; + ThF = ThD - ThE; + ThG = ThC + ThF; + ThO = ThF - ThC; + ThH = T6B - T7e; + ThK = ThI - ThJ; + ThL = ThH - ThK; + ThP = ThH + ThK; + } + { + E ThM, Ti9, ThQ, Tid; + ThM = KP707106781 * (ThG + ThL); + iio[-WS(ios, 40)] = ThB - ThM; + rio[WS(ios, 8)] = ThB + ThM; + Ti9 = KP707106781 * (ThO + ThP); + rio[WS(ios, 40)] = Ti9 - Tic; + iio[-WS(ios, 8)] = Ti9 + Tic; + ThQ = KP707106781 * (ThO - ThP); + iio[-WS(ios, 56)] = ThN - ThQ; + rio[WS(ios, 24)] = ThN + ThQ; + Tid = KP707106781 * (ThL - ThG); + rio[WS(ios, 56)] = Tid - Tie; + iio[-WS(ios, 24)] = Tid + Tie; + } + } + { + E TgP, Thd, Tiq, Tis, Th0, The, Thb, Thf; + { + E TgD, TgO, Tio, Tip; + TgD = Tgz - TgC; + TgO = KP707106781 * (TgI - TgN); + TgP = TgD + TgO; + Thd = TgD - TgO; + Tio = KP707106781 * (Thj - Thi); + Tip = Tii - Tih; + Tiq = Tio + Tip; + Tis = Tip - Tio; + } + { + E TgU, TgZ, Th5, Tha; + TgU = TgS - TgT; + TgZ = TgV - TgY; + Th0 = FMA(KP923879532, TgU, KP382683432 * TgZ); + The = FNMS(KP923879532, TgZ, KP382683432 * TgU); + Th5 = Th1 - Th4; + Tha = Th8 - Th9; + Thb = FNMS(KP923879532, Tha, KP382683432 * Th5); + Thf = FMA(KP382683432, Tha, KP923879532 * Th5); + } + { + E Thc, Tin, Thg, Tir; + Thc = Th0 + Thb; + iio[-WS(ios, 44)] = TgP - Thc; + rio[WS(ios, 12)] = TgP + Thc; + Tin = The + Thf; + rio[WS(ios, 44)] = Tin - Tiq; + iio[-WS(ios, 12)] = Tin + Tiq; + Thg = The - Thf; + iio[-WS(ios, 60)] = Thd - Thg; + rio[WS(ios, 28)] = Thd + Thg; + Tir = Thb - Th0; + rio[WS(ios, 60)] = Tir - Tis; + iio[-WS(ios, 28)] = Tir + Tis; + } + } + { + E TfB, TfJ, TiO, TiQ, TfE, TfK, TfH, TfL; + { + E Tfx, TfA, TiK, TiN; + Tfx = TdZ + Tea; + TfA = Tfy + Tfz; + TfB = Tfx + TfA; + TfJ = Tfx - TfA; + TiK = Tem + Tex; + TiN = TiL + TiM; + TiO = TiK + TiN; + TiQ = TiN - TiK; + } + { + E TfC, TfD, TfF, TfG; + TfC = TeE + TeP; + TfD = TeV + TeY; + TfE = FMA(KP555570233, TfC, KP831469612 * TfD); + TfK = FNMS(KP555570233, TfD, KP831469612 * TfC); + TfF = Tf5 + Tfg; + TfG = Tfm + Tfp; + TfH = FNMS(KP555570233, TfG, KP831469612 * TfF); + TfL = FMA(KP831469612, TfG, KP555570233 * TfF); + } + { + E TfI, TiJ, TfM, TiP; + TfI = TfE + TfH; + iio[-WS(ios, 38)] = TfB - TfI; + rio[WS(ios, 6)] = TfB + TfI; + TiJ = TfK + TfL; + rio[WS(ios, 38)] = TiJ - TiO; + iio[-WS(ios, 6)] = TiJ + TiO; + TfM = TfK - TfL; + iio[-WS(ios, 54)] = TfJ - TfM; + rio[WS(ios, 22)] = TfJ + TfM; + TiP = TfH - TfE; + rio[WS(ios, 54)] = TiP - TiQ; + iio[-WS(ios, 22)] = TiP + TiQ; + } + } + { + E Thl, Tht, Tik, Tim, Tho, Thu, Thr, Thv; + { + E Thh, Thk, Tig, Tij; + Thh = Tgz + TgC; + Thk = KP707106781 * (Thi + Thj); + Thl = Thh + Thk; + Tht = Thh - Thk; + Tig = KP707106781 * (TgI + TgN); + Tij = Tih + Tii; + Tik = Tig + Tij; + Tim = Tij - Tig; + } + { + E Thm, Thn, Thp, Thq; + Thm = TgS + TgT; + Thn = TgV + TgY; + Tho = FMA(KP382683432, Thm, KP923879532 * Thn); + Thu = FNMS(KP382683432, Thn, KP923879532 * Thm); + Thp = Th1 + Th4; + Thq = Th8 + Th9; + Thr = FNMS(KP382683432, Thq, KP923879532 * Thp); + Thv = FMA(KP923879532, Thq, KP382683432 * Thp); + } + { + E Ths, Tif, Thw, Til; + Ths = Tho + Thr; + iio[-WS(ios, 36)] = Thl - Ths; + rio[WS(ios, 4)] = Thl + Ths; + Tif = Thu + Thv; + rio[WS(ios, 36)] = Tif - Tik; + iio[-WS(ios, 4)] = Tif + Tik; + Thw = Thu - Thv; + iio[-WS(ios, 52)] = Tht - Thw; + rio[WS(ios, 20)] = Tht + Thw; + Til = Thr - Tho; + rio[WS(ios, 52)] = Til - Tim; + iio[-WS(ios, 20)] = Til + Tim; + } + } + { + E Tez, Tft, TiU, TiW, Tf0, Tfu, Tfr, Tfv; + { + E Teb, Tey, TiS, TiT; + Teb = TdZ - Tea; + Tey = Tem - Tex; + Tez = Teb + Tey; + Tft = Teb - Tey; + TiS = Tfz - Tfy; + TiT = TiM - TiL; + TiU = TiS + TiT; + TiW = TiT - TiS; + } + { + E TeQ, TeZ, Tfh, Tfq; + TeQ = TeE - TeP; + TeZ = TeV - TeY; + Tf0 = FMA(KP980785280, TeQ, KP195090322 * TeZ); + Tfu = FNMS(KP980785280, TeZ, KP195090322 * TeQ); + Tfh = Tf5 - Tfg; + Tfq = Tfm - Tfp; + Tfr = FNMS(KP980785280, Tfq, KP195090322 * Tfh); + Tfv = FMA(KP195090322, Tfq, KP980785280 * Tfh); + } + { + E Tfs, TiR, Tfw, TiV; + Tfs = Tf0 + Tfr; + iio[-WS(ios, 46)] = Tez - Tfs; + rio[WS(ios, 14)] = Tez + Tfs; + TiR = Tfu + Tfv; + rio[WS(ios, 46)] = TiR - TiU; + iio[-WS(ios, 14)] = TiR + TiU; + Tfw = Tfu - Tfv; + iio[-WS(ios, 62)] = Tft - Tfw; + rio[WS(ios, 30)] = Tft + Tfw; + TiV = Tfr - Tf0; + rio[WS(ios, 62)] = TiV - TiW; + iio[-WS(ios, 30)] = TiV + TiW; + } + } + { + E TfZ, Tgf, TiG, TiI, Tg6, Tgg, Tgd, Tgh; + { + E TfR, TfY, TiE, TiF; + TfR = TfN - TfQ; + TfY = TfU - TfX; + TfZ = TfR + TfY; + Tgf = TfR - TfY; + TiE = Tgl - Tgk; + TiF = Tiy - Tiv; + TiG = TiE + TiF; + TiI = TiF - TiE; + } + { + E Tg2, Tg5, Tg9, Tgc; + Tg2 = Tg0 - Tg1; + Tg5 = Tg3 - Tg4; + Tg6 = FMA(KP555570233, Tg2, KP831469612 * Tg5); + Tgg = FNMS(KP831469612, Tg2, KP555570233 * Tg5); + Tg9 = Tg7 - Tg8; + Tgc = Tga - Tgb; + Tgd = FNMS(KP831469612, Tgc, KP555570233 * Tg9); + Tgh = FMA(KP831469612, Tg9, KP555570233 * Tgc); + } + { + E Tge, TiD, Tgi, TiH; + Tge = Tg6 + Tgd; + iio[-WS(ios, 42)] = TfZ - Tge; + rio[WS(ios, 10)] = TfZ + Tge; + TiD = Tgg + Tgh; + rio[WS(ios, 42)] = TiD - TiG; + iio[-WS(ios, 10)] = TiD + TiG; + Tgi = Tgg - Tgh; + iio[-WS(ios, 58)] = Tgf - Tgi; + rio[WS(ios, 26)] = Tgf + Tgi; + TiH = Tgd - Tg6; + rio[WS(ios, 58)] = TiH - TiI; + iio[-WS(ios, 26)] = TiH + TiI; + } + } + { + E Tgn, Tgv, TiA, TiC, Tgq, Tgw, Tgt, Tgx; + { + E Tgj, Tgm, Tiu, Tiz; + Tgj = TfN + TfQ; + Tgm = Tgk + Tgl; + Tgn = Tgj + Tgm; + Tgv = Tgj - Tgm; + Tiu = TfU + TfX; + Tiz = Tiv + Tiy; + TiA = Tiu + Tiz; + TiC = Tiz - Tiu; + } + { + E Tgo, Tgp, Tgr, Tgs; + Tgo = Tg0 + Tg1; + Tgp = Tg3 + Tg4; + Tgq = FMA(KP980785280, Tgo, KP195090322 * Tgp); + Tgw = FNMS(KP195090322, Tgo, KP980785280 * Tgp); + Tgr = Tg7 + Tg8; + Tgs = Tga + Tgb; + Tgt = FNMS(KP195090322, Tgs, KP980785280 * Tgr); + Tgx = FMA(KP195090322, Tgr, KP980785280 * Tgs); + } + { + E Tgu, Tit, Tgy, TiB; + Tgu = Tgq + Tgt; + iio[-WS(ios, 34)] = Tgn - Tgu; + rio[WS(ios, 2)] = Tgn + Tgu; + Tit = Tgw + Tgx; + rio[WS(ios, 34)] = Tit - TiA; + iio[-WS(ios, 2)] = Tit + TiA; + Tgy = Tgw - Tgx; + iio[-WS(ios, 50)] = Tgv - Tgy; + rio[WS(ios, 18)] = Tgv + Tgy; + TiB = Tgt - Tgq; + rio[WS(ios, 50)] = TiB - TiC; + iio[-WS(ios, 18)] = TiB + TiC; + } + } + { + E T7V, TjN, TjT, TaH, T8O, TjK, TaK, TjS, TaO, TaU, T9I, TaE, TaR, TaV, TaB; + E TaF, T8N; + T7V = T7x - T7U; + TjN = TjL + TjM; + TjT = TjM - TjL; + TaH = T7x + T7U; + T8N = FMA(KP195090322, T8D, KP980785280 * T8M); + T8O = T8m - T8N; + TjK = T8m + T8N; + { + E TaJ, TaM, TaN, T9u, T9H; + TaJ = FNMS(KP980785280, T8D, KP195090322 * T8M); + TaK = TaI + TaJ; + TjS = TaJ - TaI; + TaM = T96 + T9t; + TaN = T9D + T9G; + TaO = FMA(KP634393284, TaM, KP773010453 * TaN); + TaU = FNMS(KP634393284, TaN, KP773010453 * TaM); + T9u = T96 - T9t; + T9H = T9D - T9G; + T9I = FMA(KP995184726, T9u, KP098017140 * T9H); + TaE = FNMS(KP995184726, T9H, KP098017140 * T9u); + { + E TaP, TaQ, Tan, TaA; + TaP = T9Z + Tam; + TaQ = Taw + Taz; + TaR = FNMS(KP634393284, TaQ, KP773010453 * TaP); + TaV = FMA(KP773010453, TaQ, KP634393284 * TaP); + Tan = T9Z - Tam; + TaA = Taw - Taz; + TaB = FNMS(KP995184726, TaA, KP098017140 * Tan); + TaF = FMA(KP098017140, TaA, KP995184726 * Tan); + } + } + { + E T8P, TaC, TjR, TjU; + T8P = T7V + T8O; + TaC = T9I + TaB; + iio[-WS(ios, 47)] = T8P - TaC; + rio[WS(ios, 15)] = T8P + TaC; + TjR = TaE + TaF; + TjU = TjS + TjT; + rio[WS(ios, 47)] = TjR - TjU; + iio[-WS(ios, 15)] = TjR + TjU; + } + { + E TaD, TaG, TjV, TjW; + TaD = T7V - T8O; + TaG = TaE - TaF; + iio[-WS(ios, 63)] = TaD - TaG; + rio[WS(ios, 31)] = TaD + TaG; + TjV = TaB - T9I; + TjW = TjT - TjS; + rio[WS(ios, 63)] = TjV - TjW; + iio[-WS(ios, 31)] = TjV + TjW; + } + { + E TaL, TaS, TjJ, TjO; + TaL = TaH + TaK; + TaS = TaO + TaR; + iio[-WS(ios, 39)] = TaL - TaS; + rio[WS(ios, 7)] = TaL + TaS; + TjJ = TaU + TaV; + TjO = TjK + TjN; + rio[WS(ios, 39)] = TjJ - TjO; + iio[-WS(ios, 7)] = TjJ + TjO; + } + { + E TaT, TaW, TjP, TjQ; + TaT = TaH - TaK; + TaW = TaU - TaV; + iio[-WS(ios, 55)] = TaT - TaW; + rio[WS(ios, 23)] = TaT + TaW; + TjP = TaR - TaO; + TjQ = TjN - TjK; + rio[WS(ios, 55)] = TjP - TjQ; + iio[-WS(ios, 23)] = TjP + TjQ; + } + } + { + E TbV, Tjj, Tjp, TcT, Tca, Tjg, TcW, Tjo, Td0, Td6, Tcu, TcQ, Td3, Td7, TcN; + E TcR, Tc9; + TbV = TbN - TbU; + Tjj = Tjh + Tji; + Tjp = Tji - Tjh; + TcT = TbN + TbU; + Tc9 = FMA(KP831469612, Tc5, KP555570233 * Tc8); + Tca = Tc2 - Tc9; + Tjg = Tc2 + Tc9; + { + E TcV, TcY, TcZ, Tcm, Tct; + TcV = FNMS(KP831469612, Tc8, KP555570233 * Tc5); + TcW = TcU + TcV; + Tjo = TcV - TcU; + TcY = Tce + Tcl; + TcZ = Tcp + Tcs; + Td0 = FMA(KP471396736, TcY, KP881921264 * TcZ); + Td6 = FNMS(KP471396736, TcZ, KP881921264 * TcY); + Tcm = Tce - Tcl; + Tct = Tcp - Tcs; + Tcu = FMA(KP956940335, Tcm, KP290284677 * Tct); + TcQ = FNMS(KP956940335, Tct, KP290284677 * Tcm); + { + E Td1, Td2, TcF, TcM; + Td1 = Tcx + TcE; + Td2 = TcI + TcL; + Td3 = FNMS(KP471396736, Td2, KP881921264 * Td1); + Td7 = FMA(KP881921264, Td2, KP471396736 * Td1); + TcF = Tcx - TcE; + TcM = TcI - TcL; + TcN = FNMS(KP956940335, TcM, KP290284677 * TcF); + TcR = FMA(KP290284677, TcM, KP956940335 * TcF); + } + } + { + E Tcb, TcO, Tjn, Tjq; + Tcb = TbV + Tca; + TcO = Tcu + TcN; + iio[-WS(ios, 45)] = Tcb - TcO; + rio[WS(ios, 13)] = Tcb + TcO; + Tjn = TcQ + TcR; + Tjq = Tjo + Tjp; + rio[WS(ios, 45)] = Tjn - Tjq; + iio[-WS(ios, 13)] = Tjn + Tjq; + } + { + E TcP, TcS, Tjr, Tjs; + TcP = TbV - Tca; + TcS = TcQ - TcR; + iio[-WS(ios, 61)] = TcP - TcS; + rio[WS(ios, 29)] = TcP + TcS; + Tjr = TcN - Tcu; + Tjs = Tjp - Tjo; + rio[WS(ios, 61)] = Tjr - Tjs; + iio[-WS(ios, 29)] = Tjr + Tjs; + } + { + E TcX, Td4, Tjf, Tjk; + TcX = TcT + TcW; + Td4 = Td0 + Td3; + iio[-WS(ios, 37)] = TcX - Td4; + rio[WS(ios, 5)] = TcX + Td4; + Tjf = Td6 + Td7; + Tjk = Tjg + Tjj; + rio[WS(ios, 37)] = Tjf - Tjk; + iio[-WS(ios, 5)] = Tjf + Tjk; + } + { + E Td5, Td8, Tjl, Tjm; + Td5 = TcT - TcW; + Td8 = Td6 - Td7; + iio[-WS(ios, 53)] = Td5 - Td8; + rio[WS(ios, 21)] = Td5 + Td8; + Tjl = Td3 - Td0; + Tjm = Tjj - Tjg; + rio[WS(ios, 53)] = Tjl - Tjm; + iio[-WS(ios, 21)] = Tjl + Tjm; + } + } + { + E Tb1, Tjz, TjF, Tbt, Tb8, Tju, Tbw, TjE, TbA, TbG, Tbg, Tbq, TbD, TbH, Tbn; + E Tbr, Tb7; + Tb1 = TaX - Tb0; + Tjz = Tjv + Tjy; + TjF = Tjy - Tjv; + Tbt = TaX + Tb0; + Tb7 = FMA(KP831469612, Tb5, KP555570233 * Tb6); + Tb8 = Tb4 - Tb7; + Tju = Tb4 + Tb7; + { + E Tbv, Tby, Tbz, Tbc, Tbf; + Tbv = FNMS(KP555570233, Tb5, KP831469612 * Tb6); + Tbw = Tbu + Tbv; + TjE = Tbv - Tbu; + Tby = Tba + Tbb; + Tbz = Tbd + Tbe; + TbA = FMA(KP956940335, Tby, KP290284677 * Tbz); + TbG = FNMS(KP290284677, Tby, KP956940335 * Tbz); + Tbc = Tba - Tbb; + Tbf = Tbd - Tbe; + Tbg = FMA(KP471396736, Tbc, KP881921264 * Tbf); + Tbq = FNMS(KP881921264, Tbc, KP471396736 * Tbf); + { + E TbB, TbC, Tbj, Tbm; + TbB = Tbh + Tbi; + TbC = Tbk + Tbl; + TbD = FNMS(KP290284677, TbC, KP956940335 * TbB); + TbH = FMA(KP290284677, TbB, KP956940335 * TbC); + Tbj = Tbh - Tbi; + Tbm = Tbk - Tbl; + Tbn = FNMS(KP881921264, Tbm, KP471396736 * Tbj); + Tbr = FMA(KP881921264, Tbj, KP471396736 * Tbm); + } + } + { + E Tb9, Tbo, TjD, TjG; + Tb9 = Tb1 + Tb8; + Tbo = Tbg + Tbn; + iio[-WS(ios, 43)] = Tb9 - Tbo; + rio[WS(ios, 11)] = Tb9 + Tbo; + TjD = Tbq + Tbr; + TjG = TjE + TjF; + rio[WS(ios, 43)] = TjD - TjG; + iio[-WS(ios, 11)] = TjD + TjG; + } + { + E Tbp, Tbs, TjH, TjI; + Tbp = Tb1 - Tb8; + Tbs = Tbq - Tbr; + iio[-WS(ios, 59)] = Tbp - Tbs; + rio[WS(ios, 27)] = Tbp + Tbs; + TjH = Tbn - Tbg; + TjI = TjF - TjE; + rio[WS(ios, 59)] = TjH - TjI; + iio[-WS(ios, 27)] = TjH + TjI; + } + { + E Tbx, TbE, Tjt, TjA; + Tbx = Tbt + Tbw; + TbE = TbA + TbD; + iio[-WS(ios, 35)] = Tbx - TbE; + rio[WS(ios, 3)] = Tbx + TbE; + Tjt = TbG + TbH; + TjA = Tju + Tjz; + rio[WS(ios, 35)] = Tjt - TjA; + iio[-WS(ios, 3)] = Tjt + TjA; + } + { + E TbF, TbI, TjB, TjC; + TbF = Tbt - Tbw; + TbI = TbG - TbH; + iio[-WS(ios, 51)] = TbF - TbI; + rio[WS(ios, 19)] = TbF + TbI; + TjB = TbD - TbA; + TjC = Tjz - Tju; + rio[WS(ios, 51)] = TjB - TjC; + iio[-WS(ios, 19)] = TjB + TjC; + } + } + { + E Tdd, Tj5, Tjb, TdF, Tdk, TiY, TdI, Tja, TdM, TdS, Tds, TdC, TdP, TdT, Tdz; + E TdD, Tdj; + Tdd = Td9 - Tdc; + Tj5 = TiZ + Tj4; + Tjb = Tj4 - TiZ; + TdF = Td9 + Tdc; + Tdj = FMA(KP195090322, Tdh, KP980785280 * Tdi); + Tdk = Tdg - Tdj; + TiY = Tdg + Tdj; + { + E TdH, TdK, TdL, Tdo, Tdr; + TdH = FNMS(KP195090322, Tdi, KP980785280 * Tdh); + TdI = TdG + TdH; + Tja = TdH - TdG; + TdK = Tdm + Tdn; + TdL = Tdp + Tdq; + TdM = FMA(KP995184726, TdK, KP098017140 * TdL); + TdS = FNMS(KP098017140, TdK, KP995184726 * TdL); + Tdo = Tdm - Tdn; + Tdr = Tdp - Tdq; + Tds = FMA(KP634393284, Tdo, KP773010453 * Tdr); + TdC = FNMS(KP773010453, Tdo, KP634393284 * Tdr); + { + E TdN, TdO, Tdv, Tdy; + TdN = Tdt + Tdu; + TdO = Tdw + Tdx; + TdP = FNMS(KP098017140, TdO, KP995184726 * TdN); + TdT = FMA(KP098017140, TdN, KP995184726 * TdO); + Tdv = Tdt - Tdu; + Tdy = Tdw - Tdx; + Tdz = FNMS(KP773010453, Tdy, KP634393284 * Tdv); + TdD = FMA(KP773010453, Tdv, KP634393284 * Tdy); + } + } + { + E Tdl, TdA, Tj9, Tjc; + Tdl = Tdd + Tdk; + TdA = Tds + Tdz; + iio[-WS(ios, 41)] = Tdl - TdA; + rio[WS(ios, 9)] = Tdl + TdA; + Tj9 = TdC + TdD; + Tjc = Tja + Tjb; + rio[WS(ios, 41)] = Tj9 - Tjc; + iio[-WS(ios, 9)] = Tj9 + Tjc; + } + { + E TdB, TdE, Tjd, Tje; + TdB = Tdd - Tdk; + TdE = TdC - TdD; + iio[-WS(ios, 57)] = TdB - TdE; + rio[WS(ios, 25)] = TdB + TdE; + Tjd = Tdz - Tds; + Tje = Tjb - Tja; + rio[WS(ios, 57)] = Tjd - Tje; + iio[-WS(ios, 25)] = Tjd + Tje; + } + { + E TdJ, TdQ, TiX, Tj6; + TdJ = TdF + TdI; + TdQ = TdM + TdP; + iio[-WS(ios, 33)] = TdJ - TdQ; + rio[WS(ios, 1)] = TdJ + TdQ; + TiX = TdS + TdT; + Tj6 = TiY + Tj5; + rio[WS(ios, 33)] = TiX - Tj6; + iio[-WS(ios, 1)] = TiX + Tj6; + } + { + E TdR, TdU, Tj7, Tj8; + TdR = TdF - TdI; + TdU = TdS - TdT; + iio[-WS(ios, 49)] = TdR - TdU; + rio[WS(ios, 17)] = TdR + TdU; + Tj7 = TdP - TdM; + Tj8 = Tj5 - TiY; + rio[WS(ios, 49)] = Tj7 - Tj8; + iio[-WS(ios, 17)] = Tj7 + Tj8; + } + } + } + } + return W; +} + +static const tw_instr twinstr[] = { + {TW_COS, 0, 1}, + {TW_SIN, 0, 1}, + {TW_COS, 0, 3}, + {TW_SIN, 0, 3}, + {TW_COS, 0, 9}, + {TW_SIN, 0, 9}, + {TW_COS, 0, 27}, + {TW_SIN, 0, 27}, + {TW_COS, 0, 63}, + {TW_SIN, 0, 63}, + {TW_NEXT, 1, 0} +}; + +static const hc2hc_desc desc = { 64, "hf2_64", twinstr, {880, 386, 274, 0}, &GENUS, 0, 0, 0 }; + +void X(codelet_hf2_64) (planner *p) { + X(khc2hc_dit_register) (p, hf2_64, &desc); +} diff --git a/src/fftw3/rdft/codelets/r2hc/hf2_8.c b/src/fftw3/rdft/codelets/r2hc/hf2_8.c new file mode 100644 index 0000000..663e8dd --- /dev/null +++ b/src/fftw3/rdft/codelets/r2hc/hf2_8.c @@ -0,0 +1,192 @@ +/* + * 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 21:57:27 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_hc2hc -compact -variables 4 -twiddle-log3 -n 8 -dit -name hf2_8 -include hf.h */ + +/* + * This function contains 74 FP additions, 44 FP multiplications, + * (or, 56 additions, 26 multiplications, 18 fused multiply/add), + * 50 stack variables, and 32 memory accesses + */ +/* + * Generator Id's : + * $Id: hf2_8.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: hf2_8.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: hf2_8.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + */ + +#include "hf.h" + +static const R *hf2_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 + 6) { + E T1, T1c, TJ, T17, TY, TV, TR, Tk, Tr, TN, TM, Tw, TB, TS, Te; + E T1b; + T1 = rio[0]; + T1c = iio[-WS(ios, 7)]; + { + E T9, T3, T6, T4, Tb, T7, Ta, Tg, Ti, TI, TX, Tl, Tm, Tn, TW; + E Tp, TF, Td, TA, Th, Ty, Tj, Tv, To, Tq, Tu; + T9 = rio[WS(ios, 4)]; + { + E TD, TH, TE, TG, T2, T5; + TD = rio[WS(ios, 7)]; + TH = iio[-WS(ios, 4)]; + TE = iio[0]; + TG = rio[WS(ios, 3)]; + T2 = W[2]; + T5 = W[3]; + T3 = W[0]; + T6 = W[1]; + T4 = T2 * T3; + Tb = T5 * T3; + T7 = T5 * T6; + Ta = T2 * T6; + Tg = T4 + T7; + Ti = Ta - Tb; + TI = FMA(T2, TG, T5 * TH); + TX = FNMS(T5, TG, T2 * TH); + Tl = W[4]; + Tm = W[5]; + Tn = FMA(Tl, T3, Tm * T6); + TW = FNMS(Tm, TD, Tl * TE); + Tp = FNMS(Tm, T3, Tl * T6); + TF = FMA(Tl, TD, Tm * TE); + } + Td = iio[-WS(ios, 3)]; + TA = iio[-WS(ios, 2)]; + Th = rio[WS(ios, 2)]; + Ty = rio[WS(ios, 5)]; + Tj = iio[-WS(ios, 5)]; + Tv = iio[-WS(ios, 6)]; + To = rio[WS(ios, 6)]; + Tq = iio[-WS(ios, 1)]; + Tu = rio[WS(ios, 1)]; + TJ = TF + TI; + T17 = TW + TX; + TY = TW - TX; + TV = TF - TI; + TR = FNMS(T6, Tu, T3 * Tv); + Tk = FNMS(Ti, Tj, Tg * Th); + Tr = FNMS(Tp, Tq, Tn * To); + TN = FMA(Tp, To, Tn * Tq); + TM = FMA(Ti, Th, Tg * Tj); + Tw = FMA(T3, Tu, T6 * Tv); + { + E Tx, Tz, T8, Tc; + Tx = FNMS(Tm, Ti, Tl * Tg); + Tz = FMA(Tl, Ti, Tm * Tg); + TB = FMA(Tx, Ty, Tz * TA); + TS = FNMS(Tz, Ty, Tx * TA); + T8 = T4 - T7; + Tc = Ta + Tb; + Te = FMA(T8, T9, Tc * Td); + T1b = FNMS(Tc, T9, T8 * Td); + } + } + { + E TK, T1f, T18, T19, Tt, T15, T1e, T1g, TC, T16; + TC = Tw + TB; + TK = TC + TJ; + T1f = TJ - TC; + T16 = TR + TS; + T18 = T16 - T17; + T19 = T16 + T17; + { + E Tf, Ts, T1a, T1d; + Tf = T1 + Te; + Ts = Tk + Tr; + Tt = Tf + Ts; + T15 = Tf - Ts; + T1a = TM + TN; + T1d = T1b + T1c; + T1e = T1a + T1d; + T1g = T1d - T1a; + } + iio[-WS(ios, 4)] = Tt - TK; + rio[WS(ios, 4)] = T19 - T1e; + rio[0] = Tt + TK; + iio[0] = T19 + T1e; + iio[-WS(ios, 6)] = T15 - T18; + rio[WS(ios, 6)] = T1f - T1g; + rio[WS(ios, 2)] = T15 + T18; + iio[-WS(ios, 2)] = T1f + T1g; + } + { + E TZ, T13, TP, T11, TU, T12, T1k, T1m, TL, TO; + TZ = TV - TY; + T13 = TV + TY; + TL = T1 - Te; + TO = TM - TN; + TP = TL + TO; + T11 = TL - TO; + { + E TQ, TT, T1i, T1j; + TQ = Tw - TB; + TT = TR - TS; + TU = TQ + TT; + T12 = TT - TQ; + T1i = T1c - T1b; + T1j = Tk - Tr; + T1k = T1i - T1j; + T1m = T1j + T1i; + } + { + E T10, T1h, T14, T1l; + T10 = KP707106781 * (TU + TZ); + iio[-WS(ios, 5)] = TP - T10; + rio[WS(ios, 1)] = TP + T10; + T1h = KP707106781 * (T12 + T13); + rio[WS(ios, 5)] = T1h - T1k; + iio[-WS(ios, 1)] = T1h + T1k; + T14 = KP707106781 * (T12 - T13); + iio[-WS(ios, 7)] = T11 - T14; + rio[WS(ios, 3)] = T11 + T14; + T1l = KP707106781 * (TZ - TU); + rio[WS(ios, 7)] = T1l - T1m; + iio[-WS(ios, 3)] = T1l + T1m; + } + } + } + return W; +} + +static const tw_instr twinstr[] = { + {TW_COS, 0, 1}, + {TW_SIN, 0, 1}, + {TW_COS, 0, 3}, + {TW_SIN, 0, 3}, + {TW_COS, 0, 7}, + {TW_SIN, 0, 7}, + {TW_NEXT, 1, 0} +}; + +static const hc2hc_desc desc = { 8, "hf2_8", twinstr, {56, 26, 18, 0}, &GENUS, 0, 0, 0 }; + +void X(codelet_hf2_8) (planner *p) { + X(khc2hc_dit_register) (p, hf2_8, &desc); +} diff --git a/src/fftw3/rdft/codelets/r2hc/hf_10.c b/src/fftw3/rdft/codelets/r2hc/hf_10.c new file mode 100644 index 0000000..bb970fa --- /dev/null +++ b/src/fftw3/rdft/codelets/r2hc/hf_10.c @@ -0,0 +1,253 @@ +/* + * 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 21:57:02 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_hc2hc -compact -variables 4 -n 10 -dit -name hf_10 -include hf.h */ + +/* + * This function contains 102 FP additions, 60 FP multiplications, + * (or, 72 additions, 30 multiplications, 30 fused multiply/add), + * 45 stack variables, and 40 memory accesses + */ +/* + * Generator Id's : + * $Id: hf_10.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: hf_10.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: hf_10.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + */ + +#include "hf.h" + +static const R *hf_10(R *rio, R *iio, const R *W, stride ios, int m, int dist) +{ + DK(KP587785252, +0.587785252292473129168705954639072768597652438); + DK(KP951056516, +0.951056516295153572116439333379382143405698634); + DK(KP250000000, +0.250000000000000000000000000000000000000000000); + 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 T7, T1O, TT, T1C, TF, TQ, TR, T1r, T1s, T1L, TX, TY, TZ, T16, T19; + E T1y, Ti, Tt, Tu, T1o, T1p, T1M, TU, TV, TW, T1d, T1g, T1x; + { + E T1, T1B, T6, T1A; + T1 = rio[0]; + T1B = iio[-WS(ios, 9)]; + { + E T3, T5, T2, T4; + T3 = rio[WS(ios, 5)]; + T5 = iio[-WS(ios, 4)]; + T2 = W[8]; + T4 = W[9]; + T6 = FMA(T2, T3, T4 * T5); + T1A = FNMS(T4, T3, T2 * T5); + } + T7 = T1 - T6; + T1O = T1B - T1A; + TT = T1 + T6; + T1C = T1A + T1B; + } + { + E Tz, T14, TP, T18, TE, T15, TK, T17; + { + E Tw, Ty, Tv, Tx; + Tw = rio[WS(ios, 4)]; + Ty = iio[-WS(ios, 5)]; + Tv = W[6]; + Tx = W[7]; + Tz = FMA(Tv, Tw, Tx * Ty); + T14 = FNMS(Tx, Tw, Tv * Ty); + } + { + E TM, TO, TL, TN; + TM = rio[WS(ios, 1)]; + TO = iio[-WS(ios, 8)]; + TL = W[0]; + TN = W[1]; + TP = FMA(TL, TM, TN * TO); + T18 = FNMS(TN, TM, TL * TO); + } + { + E TB, TD, TA, TC; + TB = rio[WS(ios, 9)]; + TD = iio[0]; + TA = W[16]; + TC = W[17]; + TE = FMA(TA, TB, TC * TD); + T15 = FNMS(TC, TB, TA * TD); + } + { + E TH, TJ, TG, TI; + TH = rio[WS(ios, 6)]; + TJ = iio[-WS(ios, 3)]; + TG = W[10]; + TI = W[11]; + TK = FMA(TG, TH, TI * TJ); + T17 = FNMS(TI, TH, TG * TJ); + } + TF = Tz - TE; + TQ = TK - TP; + TR = TF + TQ; + T1r = T14 - T15; + T1s = T18 - T17; + T1L = T1s - T1r; + TX = Tz + TE; + TY = TK + TP; + TZ = TX + TY; + T16 = T14 + T15; + T19 = T17 + T18; + T1y = T16 + T19; + } + { + E Tc, T1b, Th, T1c, Tn, T1e, Ts, T1f; + { + E T9, Tb, T8, Ta; + T9 = rio[WS(ios, 2)]; + Tb = iio[-WS(ios, 7)]; + T8 = W[2]; + Ta = W[3]; + Tc = FMA(T8, T9, Ta * Tb); + T1b = FNMS(Ta, T9, T8 * Tb); + } + { + E Te, Tg, Td, Tf; + Te = rio[WS(ios, 7)]; + Tg = iio[-WS(ios, 2)]; + Td = W[12]; + Tf = W[13]; + Th = FMA(Td, Te, Tf * Tg); + T1c = FNMS(Tf, Te, Td * Tg); + } + { + E Tk, Tm, Tj, Tl; + Tk = rio[WS(ios, 8)]; + Tm = iio[-WS(ios, 1)]; + Tj = W[14]; + Tl = W[15]; + Tn = FMA(Tj, Tk, Tl * Tm); + T1e = FNMS(Tl, Tk, Tj * Tm); + } + { + E Tp, Tr, To, Tq; + Tp = rio[WS(ios, 3)]; + Tr = iio[-WS(ios, 6)]; + To = W[4]; + Tq = W[5]; + Ts = FMA(To, Tp, Tq * Tr); + T1f = FNMS(Tq, Tp, To * Tr); + } + Ti = Tc - Th; + Tt = Tn - Ts; + Tu = Ti + Tt; + T1o = T1b - T1c; + T1p = T1e - T1f; + T1M = T1o + T1p; + TU = Tc + Th; + TV = Tn + Ts; + TW = TU + TV; + T1d = T1b + T1c; + T1g = T1e + T1f; + T1x = T1d + T1g; + } + { + E T1l, TS, T1m, T1u, T1w, T1q, T1t, T1v, T1n; + T1l = KP559016994 * (Tu - TR); + TS = Tu + TR; + T1m = FNMS(KP250000000, TS, T7); + T1q = T1o - T1p; + T1t = T1r + T1s; + T1u = FMA(KP951056516, T1q, KP587785252 * T1t); + T1w = FNMS(KP587785252, T1q, KP951056516 * T1t); + iio[-WS(ios, 5)] = T7 + TS; + T1v = T1m - T1l; + iio[-WS(ios, 7)] = T1v - T1w; + rio[WS(ios, 3)] = T1v + T1w; + T1n = T1l + T1m; + iio[-WS(ios, 9)] = T1n - T1u; + rio[WS(ios, 1)] = T1n + T1u; + } + { + E T1S, T1N, T1T, T1R, T1V, T1P, T1Q, T1W, T1U; + T1S = KP559016994 * (T1M + T1L); + T1N = T1L - T1M; + T1T = FMA(KP250000000, T1N, T1O); + T1P = TQ - TF; + T1Q = Ti - Tt; + T1R = FNMS(KP951056516, T1Q, KP587785252 * T1P); + T1V = FMA(KP587785252, T1Q, KP951056516 * T1P); + rio[WS(ios, 5)] = T1N - T1O; + T1W = T1T - T1S; + rio[WS(ios, 7)] = T1V - T1W; + iio[-WS(ios, 3)] = T1V + T1W; + T1U = T1S + T1T; + rio[WS(ios, 9)] = T1R - T1U; + iio[-WS(ios, 1)] = T1R + T1U; + } + { + E T12, T10, T11, T1i, T1k, T1a, T1h, T1j, T13; + T12 = KP559016994 * (TW - TZ); + T10 = TW + TZ; + T11 = FNMS(KP250000000, T10, TT); + T1a = T16 - T19; + T1h = T1d - T1g; + T1i = FNMS(KP587785252, T1h, KP951056516 * T1a); + T1k = FMA(KP951056516, T1h, KP587785252 * T1a); + rio[0] = TT + T10; + T1j = T12 + T11; + rio[WS(ios, 4)] = T1j - T1k; + iio[-WS(ios, 6)] = T1j + T1k; + T13 = T11 - T12; + rio[WS(ios, 2)] = T13 - T1i; + iio[-WS(ios, 8)] = T13 + T1i; + } + { + E T1H, T1z, T1G, T1F, T1J, T1D, T1E, T1K, T1I; + T1H = KP559016994 * (T1x - T1y); + T1z = T1x + T1y; + T1G = FNMS(KP250000000, T1z, T1C); + T1D = TX - TY; + T1E = TU - TV; + T1F = FNMS(KP587785252, T1E, KP951056516 * T1D); + T1J = FMA(KP951056516, T1E, KP587785252 * T1D); + iio[0] = T1z + T1C; + T1K = T1H + T1G; + rio[WS(ios, 6)] = T1J - T1K; + iio[-WS(ios, 4)] = T1J + T1K; + T1I = T1G - T1H; + rio[WS(ios, 8)] = T1F - T1I; + iio[-WS(ios, 2)] = T1F + T1I; + } + } + return W; +} + +static const tw_instr twinstr[] = { + {TW_FULL, 0, 10}, + {TW_NEXT, 1, 0} +}; + +static const hc2hc_desc desc = { 10, "hf_10", twinstr, {72, 30, 30, 0}, &GENUS, 0, 0, 0 }; + +void X(codelet_hf_10) (planner *p) { + X(khc2hc_dit_register) (p, hf_10, &desc); +} diff --git a/src/fftw3/rdft/codelets/r2hc/hf_12.c b/src/fftw3/rdft/codelets/r2hc/hf_12.c new file mode 100644 index 0000000..e399159 --- /dev/null +++ b/src/fftw3/rdft/codelets/r2hc/hf_12.c @@ -0,0 +1,300 @@ +/* + * 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 21:57:06 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_hc2hc -compact -variables 4 -n 12 -dit -name hf_12 -include hf.h */ + +/* + * This function contains 118 FP additions, 60 FP multiplications, + * (or, 88 additions, 30 multiplications, 30 fused multiply/add), + * 47 stack variables, and 48 memory accesses + */ +/* + * Generator Id's : + * $Id: hf_12.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: hf_12.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: hf_12.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + */ + +#include "hf.h" + +static const R *hf_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 T1, T1W, T18, T22, Tc, T15, T1V, T23, TA, T1y, T1j, T1B, TL, T1g, T1z; + E T1A, Ti, T1S, T1d, T25, Tt, T1a, T1T, T26, TR, T1E, T1o, T1D, T12, T1l; + E T1F, T1G; + { + E T6, T16, Tb, T17; + T1 = rio[0]; + T1W = iio[-WS(ios, 11)]; + { + E T3, T5, T2, T4; + T3 = rio[WS(ios, 4)]; + T5 = iio[-WS(ios, 7)]; + T2 = W[6]; + T4 = W[7]; + T6 = FMA(T2, T3, T4 * T5); + T16 = FNMS(T4, T3, T2 * T5); + } + { + E T8, Ta, T7, T9; + T8 = rio[WS(ios, 8)]; + Ta = iio[-WS(ios, 3)]; + T7 = W[14]; + T9 = W[15]; + Tb = FMA(T7, T8, T9 * Ta); + T17 = FNMS(T9, T8, T7 * Ta); + } + T18 = KP866025403 * (T16 - T17); + T22 = KP866025403 * (Tb - T6); + Tc = T6 + Tb; + T15 = FNMS(KP500000000, Tc, T1); + T1V = T16 + T17; + T23 = FNMS(KP500000000, T1V, T1W); + } + { + E TK, T1i, TF, T1h; + { + E Tx, Tz, Tw, Ty; + Tx = rio[WS(ios, 3)]; + Tz = iio[-WS(ios, 8)]; + Tw = W[4]; + Ty = W[5]; + TA = FMA(Tw, Tx, Ty * Tz); + T1y = FNMS(Ty, Tx, Tw * Tz); + } + { + E TH, TJ, TG, TI; + TH = rio[WS(ios, 11)]; + TJ = iio[0]; + TG = W[20]; + TI = W[21]; + TK = FMA(TG, TH, TI * TJ); + T1i = FNMS(TI, TH, TG * TJ); + } + { + E TC, TE, TB, TD; + TC = rio[WS(ios, 7)]; + TE = iio[-WS(ios, 4)]; + TB = W[12]; + TD = W[13]; + TF = FMA(TB, TC, TD * TE); + T1h = FNMS(TD, TC, TB * TE); + } + T1j = KP866025403 * (T1h - T1i); + T1B = KP866025403 * (TK - TF); + TL = TF + TK; + T1g = FNMS(KP500000000, TL, TA); + T1z = T1h + T1i; + T1A = FNMS(KP500000000, T1z, T1y); + } + { + E Ts, T1c, Tn, T1b; + { + E Tf, Th, Te, Tg; + Tf = rio[WS(ios, 6)]; + Th = iio[-WS(ios, 5)]; + Te = W[10]; + Tg = W[11]; + Ti = FMA(Te, Tf, Tg * Th); + T1S = FNMS(Tg, Tf, Te * Th); + } + { + E Tp, Tr, To, Tq; + Tp = rio[WS(ios, 2)]; + Tr = iio[-WS(ios, 9)]; + To = W[2]; + Tq = W[3]; + Ts = FMA(To, Tp, Tq * Tr); + T1c = FNMS(Tq, Tp, To * Tr); + } + { + E Tk, Tm, Tj, Tl; + Tk = rio[WS(ios, 10)]; + Tm = iio[-WS(ios, 1)]; + Tj = W[18]; + Tl = W[19]; + Tn = FMA(Tj, Tk, Tl * Tm); + T1b = FNMS(Tl, Tk, Tj * Tm); + } + T1d = KP866025403 * (T1b - T1c); + T25 = KP866025403 * (Ts - Tn); + Tt = Tn + Ts; + T1a = FNMS(KP500000000, Tt, Ti); + T1T = T1b + T1c; + T26 = FNMS(KP500000000, T1T, T1S); + } + { + E T11, T1n, TW, T1m; + { + E TO, TQ, TN, TP; + TO = rio[WS(ios, 9)]; + TQ = iio[-WS(ios, 2)]; + TN = W[16]; + TP = W[17]; + TR = FMA(TN, TO, TP * TQ); + T1E = FNMS(TP, TO, TN * TQ); + } + { + E TY, T10, TX, TZ; + TY = rio[WS(ios, 5)]; + T10 = iio[-WS(ios, 6)]; + TX = W[8]; + TZ = W[9]; + T11 = FMA(TX, TY, TZ * T10); + T1n = FNMS(TZ, TY, TX * T10); + } + { + E TT, TV, TS, TU; + TT = rio[WS(ios, 1)]; + TV = iio[-WS(ios, 10)]; + TS = W[0]; + TU = W[1]; + TW = FMA(TS, TT, TU * TV); + T1m = FNMS(TU, TT, TS * TV); + } + T1o = KP866025403 * (T1m - T1n); + T1D = KP866025403 * (T11 - TW); + T12 = TW + T11; + T1l = FNMS(KP500000000, T12, TR); + T1F = T1m + T1n; + T1G = FNMS(KP500000000, T1F, T1E); + } + { + E Tv, T1N, T1Y, T20, T14, T1Z, T1Q, T1R; + { + E Td, Tu, T1U, T1X; + Td = T1 + Tc; + Tu = Ti + Tt; + Tv = Td + Tu; + T1N = Td - Tu; + T1U = T1S + T1T; + T1X = T1V + T1W; + T1Y = T1U + T1X; + T20 = T1X - T1U; + } + { + E TM, T13, T1O, T1P; + TM = TA + TL; + T13 = TR + T12; + T14 = TM + T13; + T1Z = TM - T13; + T1O = T1y + T1z; + T1P = T1E + T1F; + T1Q = T1O - T1P; + T1R = T1O + T1P; + } + iio[-WS(ios, 6)] = Tv - T14; + rio[WS(ios, 6)] = T1R - T1Y; + rio[0] = Tv + T14; + iio[0] = T1R + T1Y; + rio[WS(ios, 3)] = T1N - T1Q; + iio[-WS(ios, 3)] = T1Z + T20; + iio[-WS(ios, 9)] = T1N + T1Q; + rio[WS(ios, 9)] = T1Z - T20; + } + { + E T1t, T1J, T28, T2a, T1w, T21, T1M, T29; + { + E T1r, T1s, T24, T27; + T1r = T15 + T18; + T1s = T1a + T1d; + T1t = T1r + T1s; + T1J = T1r - T1s; + T24 = T22 + T23; + T27 = T25 + T26; + T28 = T24 - T27; + T2a = T27 + T24; + } + { + E T1u, T1v, T1K, T1L; + T1u = T1g + T1j; + T1v = T1l + T1o; + T1w = T1u + T1v; + T21 = T1v - T1u; + T1K = T1B + T1A; + T1L = T1D + T1G; + T1M = T1K - T1L; + T29 = T1K + T1L; + } + iio[-WS(ios, 10)] = T1t - T1w; + rio[WS(ios, 10)] = T29 - T2a; + rio[WS(ios, 4)] = T1t + T1w; + iio[-WS(ios, 4)] = T29 + T2a; + iio[-WS(ios, 7)] = T1J - T1M; + rio[WS(ios, 7)] = T21 - T28; + rio[WS(ios, 1)] = T1J + T1M; + iio[-WS(ios, 1)] = T21 + T28; + } + { + E T1f, T1x, T2e, T2g, T1q, T2f, T1I, T2b; + { + E T19, T1e, T2c, T2d; + T19 = T15 - T18; + T1e = T1a - T1d; + T1f = T19 + T1e; + T1x = T19 - T1e; + T2c = T26 - T25; + T2d = T23 - T22; + T2e = T2c + T2d; + T2g = T2d - T2c; + } + { + E T1k, T1p, T1C, T1H; + T1k = T1g - T1j; + T1p = T1l - T1o; + T1q = T1k + T1p; + T2f = T1p - T1k; + T1C = T1A - T1B; + T1H = T1D - T1G; + T1I = T1C + T1H; + T2b = T1H - T1C; + } + rio[WS(ios, 2)] = T1f - T1q; + iio[-WS(ios, 2)] = T2b + T2e; + iio[-WS(ios, 8)] = T1f + T1q; + rio[WS(ios, 8)] = T2b - T2e; + iio[-WS(ios, 11)] = T1x - T1I; + rio[WS(ios, 11)] = T2f - T2g; + rio[WS(ios, 5)] = T1x + T1I; + iio[-WS(ios, 5)] = T2f + T2g; + } + } + return W; +} + +static const tw_instr twinstr[] = { + {TW_FULL, 0, 12}, + {TW_NEXT, 1, 0} +}; + +static const hc2hc_desc desc = { 12, "hf_12", twinstr, {88, 30, 30, 0}, &GENUS, 0, 0, 0 }; + +void X(codelet_hf_12) (planner *p) { + X(khc2hc_dit_register) (p, hf_12, &desc); +} diff --git a/src/fftw3/rdft/codelets/r2hc/hf_15.c b/src/fftw3/rdft/codelets/r2hc/hf_15.c new file mode 100644 index 0000000..71a3b40 --- /dev/null +++ b/src/fftw3/rdft/codelets/r2hc/hf_15.c @@ -0,0 +1,405 @@ +/* + * 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 21:57:07 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_hc2hc -compact -variables 4 -n 15 -dit -name hf_15 -include hf.h */ + +/* + * This function contains 184 FP additions, 112 FP multiplications, + * (or, 128 additions, 56 multiplications, 56 fused multiply/add), + * 65 stack variables, and 60 memory accesses + */ +/* + * Generator Id's : + * $Id: hf_15.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: hf_15.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: hf_15.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + */ + +#include "hf.h" + +static const R *hf_15(R *rio, R *iio, const R *W, stride ios, int m, int dist) +{ + DK(KP587785252, +0.587785252292473129168705954639072768597652438); + DK(KP951056516, +0.951056516295153572116439333379382143405698634); + DK(KP250000000, +0.250000000000000000000000000000000000000000000); + DK(KP559016994, +0.559016994374947424102293417182819058860154590); + 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 T1q, T34, Td, T1n, T2S, T35, T13, T1k, T1l, T2E, T2F, T2O, T1H, T1T, T2k; + E T2t, T2f, T2s, T1M, T1U, Tu, TL, TM, T2H, T2I, T2N, T1w, T1Q, T29, T2w; + E T24, T2v, T1B, T1R; + { + E T1, T2R, T6, T1o, Tb, T1p, Tc, T2Q; + T1 = rio[0]; + T2R = iio[-WS(ios, 14)]; + { + E T3, T5, T2, T4; + T3 = rio[WS(ios, 5)]; + T5 = iio[-WS(ios, 9)]; + T2 = W[8]; + T4 = W[9]; + T6 = FMA(T2, T3, T4 * T5); + T1o = FNMS(T4, T3, T2 * T5); + } + { + E T8, Ta, T7, T9; + T8 = rio[WS(ios, 10)]; + Ta = iio[-WS(ios, 4)]; + T7 = W[18]; + T9 = W[19]; + Tb = FMA(T7, T8, T9 * Ta); + T1p = FNMS(T9, T8, T7 * Ta); + } + T1q = KP866025403 * (T1o - T1p); + T34 = KP866025403 * (Tb - T6); + Tc = T6 + Tb; + Td = T1 + Tc; + T1n = FNMS(KP500000000, Tc, T1); + T2Q = T1o + T1p; + T2S = T2Q + T2R; + T35 = FNMS(KP500000000, T2Q, T2R); + } + { + E TR, T2c, T18, T2h, TW, T1E, T11, T1F, T12, T2d, T1d, T1J, T1i, T1K, T1j; + E T2i; + { + E TO, TQ, TN, TP; + TO = rio[WS(ios, 6)]; + TQ = iio[-WS(ios, 8)]; + TN = W[10]; + TP = W[11]; + TR = FMA(TN, TO, TP * TQ); + T2c = FNMS(TP, TO, TN * TQ); + } + { + E T15, T17, T14, T16; + T15 = rio[WS(ios, 9)]; + T17 = iio[-WS(ios, 5)]; + T14 = W[16]; + T16 = W[17]; + T18 = FMA(T14, T15, T16 * T17); + T2h = FNMS(T16, T15, T14 * T17); + } + { + E TT, TV, TS, TU; + TT = rio[WS(ios, 11)]; + TV = iio[-WS(ios, 3)]; + TS = W[20]; + TU = W[21]; + TW = FMA(TS, TT, TU * TV); + T1E = FNMS(TU, TT, TS * TV); + } + { + E TY, T10, TX, TZ; + TY = rio[WS(ios, 1)]; + T10 = iio[-WS(ios, 13)]; + TX = W[0]; + TZ = W[1]; + T11 = FMA(TX, TY, TZ * T10); + T1F = FNMS(TZ, TY, TX * T10); + } + T12 = TW + T11; + T2d = T1E + T1F; + { + E T1a, T1c, T19, T1b; + T1a = rio[WS(ios, 14)]; + T1c = iio[0]; + T19 = W[26]; + T1b = W[27]; + T1d = FMA(T19, T1a, T1b * T1c); + T1J = FNMS(T1b, T1a, T19 * T1c); + } + { + E T1f, T1h, T1e, T1g; + T1f = rio[WS(ios, 4)]; + T1h = iio[-WS(ios, 10)]; + T1e = W[6]; + T1g = W[7]; + T1i = FMA(T1e, T1f, T1g * T1h); + T1K = FNMS(T1g, T1f, T1e * T1h); + } + T1j = T1d + T1i; + T2i = T1J + T1K; + { + E T1D, T1G, T2g, T2j; + T13 = TR + T12; + T1k = T18 + T1j; + T1l = T13 + T1k; + T2E = T2c + T2d; + T2F = T2h + T2i; + T2O = T2E + T2F; + T1D = FNMS(KP500000000, T12, TR); + T1G = KP866025403 * (T1E - T1F); + T1H = T1D - T1G; + T1T = T1D + T1G; + T2g = KP866025403 * (T1d - T1i); + T2j = FNMS(KP500000000, T2i, T2h); + T2k = T2g - T2j; + T2t = T2g + T2j; + { + E T2b, T2e, T1I, T1L; + T2b = KP866025403 * (T11 - TW); + T2e = FNMS(KP500000000, T2d, T2c); + T2f = T2b + T2e; + T2s = T2e - T2b; + T1I = FNMS(KP500000000, T1j, T18); + T1L = KP866025403 * (T1J - T1K); + T1M = T1I - T1L; + T1U = T1I + T1L; + } + } + } + { + E Ti, T21, Tz, T26, TE, T1y, TJ, T1z, TK, T27, Tn, T1t, Ts, T1u, Tt; + E T22; + { + E Tf, Th, Te, Tg; + Tf = rio[WS(ios, 3)]; + Th = iio[-WS(ios, 11)]; + Te = W[4]; + Tg = W[5]; + Ti = FMA(Te, Tf, Tg * Th); + T21 = FNMS(Tg, Tf, Te * Th); + } + { + E Tw, Ty, Tv, Tx; + Tw = rio[WS(ios, 12)]; + Ty = iio[-WS(ios, 2)]; + Tv = W[22]; + Tx = W[23]; + Tz = FMA(Tv, Tw, Tx * Ty); + T26 = FNMS(Tx, Tw, Tv * Ty); + } + { + E TB, TD, TA, TC; + TB = rio[WS(ios, 2)]; + TD = iio[-WS(ios, 12)]; + TA = W[2]; + TC = W[3]; + TE = FMA(TA, TB, TC * TD); + T1y = FNMS(TC, TB, TA * TD); + } + { + E TG, TI, TF, TH; + TG = rio[WS(ios, 7)]; + TI = iio[-WS(ios, 7)]; + TF = W[12]; + TH = W[13]; + TJ = FMA(TF, TG, TH * TI); + T1z = FNMS(TH, TG, TF * TI); + } + TK = TE + TJ; + T27 = T1y + T1z; + { + E Tk, Tm, Tj, Tl; + Tk = rio[WS(ios, 8)]; + Tm = iio[-WS(ios, 6)]; + Tj = W[14]; + Tl = W[15]; + Tn = FMA(Tj, Tk, Tl * Tm); + T1t = FNMS(Tl, Tk, Tj * Tm); + } + { + E Tp, Tr, To, Tq; + Tp = rio[WS(ios, 13)]; + Tr = iio[-WS(ios, 1)]; + To = W[24]; + Tq = W[25]; + Ts = FMA(To, Tp, Tq * Tr); + T1u = FNMS(Tq, Tp, To * Tr); + } + Tt = Tn + Ts; + T22 = T1t + T1u; + { + E T1s, T1v, T25, T28; + Tu = Ti + Tt; + TL = Tz + TK; + TM = Tu + TL; + T2H = T21 + T22; + T2I = T26 + T27; + T2N = T2H + T2I; + T1s = FNMS(KP500000000, Tt, Ti); + T1v = KP866025403 * (T1t - T1u); + T1w = T1s - T1v; + T1Q = T1s + T1v; + T25 = KP866025403 * (TJ - TE); + T28 = FNMS(KP500000000, T27, T26); + T29 = T25 + T28; + T2w = T28 - T25; + { + E T20, T23, T1x, T1A; + T20 = KP866025403 * (Ts - Tn); + T23 = FNMS(KP500000000, T22, T21); + T24 = T20 + T23; + T2v = T23 - T20; + T1x = FNMS(KP500000000, TK, Tz); + T1A = KP866025403 * (T1y - T1z); + T1B = T1x - T1A; + T1R = T1x + T1A; + } + } + } + { + E T2C, T1m, T2B, T2K, T2M, T2G, T2J, T2L, T2D; + T2C = KP559016994 * (TM - T1l); + T1m = TM + T1l; + T2B = FNMS(KP250000000, T1m, Td); + T2G = T2E - T2F; + T2J = T2H - T2I; + T2K = FNMS(KP587785252, T2J, KP951056516 * T2G); + T2M = FMA(KP951056516, T2J, KP587785252 * T2G); + rio[0] = Td + T1m; + T2L = T2C + T2B; + iio[-WS(ios, 9)] = T2L - T2M; + rio[WS(ios, 6)] = T2L + T2M; + T2D = T2B - T2C; + iio[-WS(ios, 12)] = T2D - T2K; + rio[WS(ios, 3)] = T2D + T2K; + } + { + E T2X, T2P, T2W, T2V, T2Z, T2T, T2U, T30, T2Y; + T2X = KP559016994 * (T2N - T2O); + T2P = T2N + T2O; + T2W = FNMS(KP250000000, T2P, T2S); + T2T = Tu - TL; + T2U = T1k - T13; + T2V = FMA(KP587785252, T2T, KP951056516 * T2U); + T2Z = FNMS(KP951056516, T2T, KP587785252 * T2U); + iio[0] = T2P + T2S; + T30 = T2X + T2W; + rio[WS(ios, 9)] = T2Z - T30; + iio[-WS(ios, 6)] = T2Z + T30; + T2Y = T2W - T2X; + rio[WS(ios, 12)] = T2V - T2Y; + iio[-WS(ios, 3)] = T2V + T2Y; + } + { + E T2y, T2A, T1r, T1O, T2p, T2q, T2z, T2r; + { + E T2u, T2x, T1C, T1N; + T2u = T2s - T2t; + T2x = T2v - T2w; + T2y = FNMS(KP587785252, T2x, KP951056516 * T2u); + T2A = FMA(KP951056516, T2x, KP587785252 * T2u); + T1r = T1n - T1q; + T1C = T1w + T1B; + T1N = T1H + T1M; + T1O = T1C + T1N; + T2p = FNMS(KP250000000, T1O, T1r); + T2q = KP559016994 * (T1C - T1N); + } + rio[WS(ios, 5)] = T1r + T1O; + T2z = T2q + T2p; + iio[-WS(ios, 14)] = T2z - T2A; + iio[-WS(ios, 11)] = T2z + T2A; + T2r = T2p - T2q; + rio[WS(ios, 2)] = T2r - T2y; + iio[-WS(ios, 8)] = T2r + T2y; + } + { + E T3h, T3p, T3l, T3m, T3k, T3n, T3q, T3o; + { + E T3f, T3g, T3i, T3j; + T3f = T1w - T1B; + T3g = T1H - T1M; + T3h = FMA(KP951056516, T3f, KP587785252 * T3g); + T3p = FNMS(KP587785252, T3f, KP951056516 * T3g); + T3l = T35 - T34; + T3i = T2s + T2t; + T3j = T2v + T2w; + T3m = T3j + T3i; + T3k = KP559016994 * (T3i - T3j); + T3n = FNMS(KP250000000, T3m, T3l); + } + iio[-WS(ios, 5)] = T3m + T3l; + T3q = T3k + T3n; + rio[WS(ios, 8)] = T3p - T3q; + iio[-WS(ios, 2)] = T3p + T3q; + T3o = T3k - T3n; + rio[WS(ios, 11)] = T3h + T3o; + rio[WS(ios, 14)] = T3o - T3h; + } + { + E T3c, T3d, T36, T33, T37, T38, T3e, T39; + { + E T3a, T3b, T31, T32; + T3a = T1Q - T1R; + T3b = T1T - T1U; + T3c = FMA(KP951056516, T3a, KP587785252 * T3b); + T3d = FNMS(KP587785252, T3a, KP951056516 * T3b); + T36 = T34 + T35; + T31 = T2k - T2f; + T32 = T24 + T29; + T33 = T31 - T32; + T37 = KP559016994 * (T32 + T31); + T38 = FMA(KP250000000, T33, T36); + } + rio[WS(ios, 10)] = T33 - T36; + T3e = T38 - T37; + rio[WS(ios, 13)] = T3d - T3e; + iio[-WS(ios, 7)] = T3d + T3e; + T39 = T37 + T38; + iio[-WS(ios, 1)] = T39 - T3c; + iio[-WS(ios, 4)] = T3c + T39; + } + { + E T2m, T2o, T1P, T1W, T1X, T1Y, T2n, T1Z; + { + E T2a, T2l, T1S, T1V; + T2a = T24 - T29; + T2l = T2f + T2k; + T2m = FMA(KP951056516, T2a, KP587785252 * T2l); + T2o = FNMS(KP587785252, T2a, KP951056516 * T2l); + T1P = T1n + T1q; + T1S = T1Q + T1R; + T1V = T1T + T1U; + T1W = T1S + T1V; + T1X = KP559016994 * (T1S - T1V); + T1Y = FNMS(KP250000000, T1W, T1P); + } + iio[-WS(ios, 10)] = T1P + T1W; + T2n = T1Y - T1X; + rio[WS(ios, 7)] = T2n - T2o; + iio[-WS(ios, 13)] = T2n + T2o; + T1Z = T1X + T1Y; + rio[WS(ios, 4)] = T1Z - T2m; + rio[WS(ios, 1)] = T1Z + T2m; + } + } + return W; +} + +static const tw_instr twinstr[] = { + {TW_FULL, 0, 15}, + {TW_NEXT, 1, 0} +}; + +static const hc2hc_desc desc = { 15, "hf_15", twinstr, {128, 56, 56, 0}, &GENUS, 0, 0, 0 }; + +void X(codelet_hf_15) (planner *p) { + X(khc2hc_dit_register) (p, hf_15, &desc); +} diff --git a/src/fftw3/rdft/codelets/r2hc/hf_16.c b/src/fftw3/rdft/codelets/r2hc/hf_16.c new file mode 100644 index 0000000..ff3145d --- /dev/null +++ b/src/fftw3/rdft/codelets/r2hc/hf_16.c @@ -0,0 +1,406 @@ +/* + * 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 21:57:07 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_hc2hc -compact -variables 4 -n 16 -dit -name hf_16 -include hf.h */ + +/* + * This function contains 174 FP additions, 84 FP multiplications, + * (or, 136 additions, 46 multiplications, 38 fused multiply/add), + * 52 stack variables, and 64 memory accesses + */ +/* + * Generator Id's : + * $Id: hf_16.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: hf_16.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: hf_16.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + */ + +#include "hf.h" + +static const R *hf_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, T37, T1t, T2U, Ti, T38, T1w, T2R, Tu, T2s, T1C, T2c, TF, T2t, T1H; + E T2d, TS, T13, T2w, T2x, T2y, T2z, T1O, T2g, T1T, T2h, T1f, T1q, T2B, T2C; + E T2D, T2E, T1Z, T2j, T24, T2k; + { + E T1, T2T, T6, T2S; + T1 = rio[0]; + T2T = iio[-WS(ios, 15)]; + { + E T3, T5, T2, T4; + T3 = rio[WS(ios, 8)]; + T5 = iio[-WS(ios, 7)]; + T2 = W[14]; + T4 = W[15]; + T6 = FMA(T2, T3, T4 * T5); + T2S = FNMS(T4, T3, T2 * T5); + } + T7 = T1 + T6; + T37 = T2T - T2S; + T1t = T1 - T6; + T2U = T2S + T2T; + } + { + E Tc, T1u, Th, T1v; + { + E T9, Tb, T8, Ta; + T9 = rio[WS(ios, 4)]; + Tb = iio[-WS(ios, 11)]; + T8 = W[6]; + Ta = W[7]; + Tc = FMA(T8, T9, Ta * Tb); + T1u = FNMS(Ta, T9, T8 * Tb); + } + { + E Te, Tg, Td, Tf; + Te = rio[WS(ios, 12)]; + Tg = iio[-WS(ios, 3)]; + Td = W[22]; + Tf = W[23]; + Th = FMA(Td, Te, Tf * Tg); + T1v = FNMS(Tf, Te, Td * Tg); + } + Ti = Tc + Th; + T38 = Tc - Th; + T1w = T1u - T1v; + T2R = T1u + T1v; + } + { + E To, T1y, Tt, T1z, T1A, T1B; + { + E Tl, Tn, Tk, Tm; + Tl = rio[WS(ios, 2)]; + Tn = iio[-WS(ios, 13)]; + Tk = W[2]; + Tm = W[3]; + To = FMA(Tk, Tl, Tm * Tn); + T1y = FNMS(Tm, Tl, Tk * Tn); + } + { + E Tq, Ts, Tp, Tr; + Tq = rio[WS(ios, 10)]; + Ts = iio[-WS(ios, 5)]; + Tp = W[18]; + Tr = W[19]; + Tt = FMA(Tp, Tq, Tr * Ts); + T1z = FNMS(Tr, Tq, Tp * Ts); + } + Tu = To + Tt; + T2s = T1y + T1z; + T1A = T1y - T1z; + T1B = To - Tt; + T1C = T1A - T1B; + T2c = T1B + T1A; + } + { + E Tz, T1E, TE, T1F, T1D, T1G; + { + E Tw, Ty, Tv, Tx; + Tw = rio[WS(ios, 14)]; + Ty = iio[-WS(ios, 1)]; + Tv = W[26]; + Tx = W[27]; + Tz = FMA(Tv, Tw, Tx * Ty); + T1E = FNMS(Tx, Tw, Tv * Ty); + } + { + E TB, TD, TA, TC; + TB = rio[WS(ios, 6)]; + TD = iio[-WS(ios, 9)]; + TA = W[10]; + TC = W[11]; + TE = FMA(TA, TB, TC * TD); + T1F = FNMS(TC, TB, TA * TD); + } + TF = Tz + TE; + T2t = T1E + T1F; + T1D = Tz - TE; + T1G = T1E - T1F; + T1H = T1D + T1G; + T2d = T1D - T1G; + } + { + E TM, T1K, T12, T1R, TR, T1L, TX, T1Q; + { + E TJ, TL, TI, TK; + TJ = rio[WS(ios, 1)]; + TL = iio[-WS(ios, 14)]; + TI = W[0]; + TK = W[1]; + TM = FMA(TI, TJ, TK * TL); + T1K = FNMS(TK, TJ, TI * TL); + } + { + E TZ, T11, TY, T10; + TZ = rio[WS(ios, 13)]; + T11 = iio[-WS(ios, 2)]; + TY = W[24]; + T10 = W[25]; + T12 = FMA(TY, TZ, T10 * T11); + T1R = FNMS(T10, TZ, TY * T11); + } + { + E TO, TQ, TN, TP; + TO = rio[WS(ios, 9)]; + TQ = iio[-WS(ios, 6)]; + TN = W[16]; + TP = W[17]; + TR = FMA(TN, TO, TP * TQ); + T1L = FNMS(TP, TO, TN * TQ); + } + { + E TU, TW, TT, TV; + TU = rio[WS(ios, 5)]; + TW = iio[-WS(ios, 10)]; + TT = W[8]; + TV = W[9]; + TX = FMA(TT, TU, TV * TW); + T1Q = FNMS(TV, TU, TT * TW); + } + TS = TM + TR; + T13 = TX + T12; + T2w = TS - T13; + T2x = T1K + T1L; + T2y = T1Q + T1R; + T2z = T2x - T2y; + { + E T1M, T1N, T1P, T1S; + T1M = T1K - T1L; + T1N = TX - T12; + T1O = T1M + T1N; + T2g = T1M - T1N; + T1P = TM - TR; + T1S = T1Q - T1R; + T1T = T1P - T1S; + T2h = T1P + T1S; + } + } + { + E T19, T20, T1p, T1X, T1e, T21, T1k, T1W; + { + E T16, T18, T15, T17; + T16 = rio[WS(ios, 15)]; + T18 = iio[0]; + T15 = W[28]; + T17 = W[29]; + T19 = FMA(T15, T16, T17 * T18); + T20 = FNMS(T17, T16, T15 * T18); + } + { + E T1m, T1o, T1l, T1n; + T1m = rio[WS(ios, 11)]; + T1o = iio[-WS(ios, 4)]; + T1l = W[20]; + T1n = W[21]; + T1p = FMA(T1l, T1m, T1n * T1o); + T1X = FNMS(T1n, T1m, T1l * T1o); + } + { + E T1b, T1d, T1a, T1c; + T1b = rio[WS(ios, 7)]; + T1d = iio[-WS(ios, 8)]; + T1a = W[12]; + T1c = W[13]; + T1e = FMA(T1a, T1b, T1c * T1d); + T21 = FNMS(T1c, T1b, T1a * T1d); + } + { + E T1h, T1j, T1g, T1i; + T1h = rio[WS(ios, 3)]; + T1j = iio[-WS(ios, 12)]; + T1g = W[4]; + T1i = W[5]; + T1k = FMA(T1g, T1h, T1i * T1j); + T1W = FNMS(T1i, T1h, T1g * T1j); + } + T1f = T19 + T1e; + T1q = T1k + T1p; + T2B = T1f - T1q; + T2C = T20 + T21; + T2D = T1W + T1X; + T2E = T2C - T2D; + { + E T1V, T1Y, T22, T23; + T1V = T19 - T1e; + T1Y = T1W - T1X; + T1Z = T1V - T1Y; + T2j = T1V + T1Y; + T22 = T20 - T21; + T23 = T1k - T1p; + T24 = T22 + T23; + T2k = T22 - T23; + } + } + { + E T1J, T27, T3g, T3i, T26, T3h, T2a, T3d; + { + E T1x, T1I, T3e, T3f; + T1x = T1t - T1w; + T1I = KP707106781 * (T1C - T1H); + T1J = T1x + T1I; + T27 = T1x - T1I; + T3e = KP707106781 * (T2d - T2c); + T3f = T38 + T37; + T3g = T3e + T3f; + T3i = T3f - T3e; + } + { + E T1U, T25, T28, T29; + T1U = FMA(KP923879532, T1O, KP382683432 * T1T); + T25 = FNMS(KP923879532, T24, KP382683432 * T1Z); + T26 = T1U + T25; + T3h = T25 - T1U; + T28 = FNMS(KP923879532, T1T, KP382683432 * T1O); + T29 = FMA(KP382683432, T24, KP923879532 * T1Z); + T2a = T28 - T29; + T3d = T28 + T29; + } + iio[-WS(ios, 11)] = T1J - T26; + rio[WS(ios, 11)] = T3d - T3g; + rio[WS(ios, 3)] = T1J + T26; + iio[-WS(ios, 3)] = T3d + T3g; + iio[-WS(ios, 15)] = T27 - T2a; + rio[WS(ios, 15)] = T3h - T3i; + rio[WS(ios, 7)] = T27 + T2a; + iio[-WS(ios, 7)] = T3h + T3i; + } + { + E T2v, T2H, T32, T34, T2G, T33, T2K, T2Z; + { + E T2r, T2u, T30, T31; + T2r = T7 - Ti; + T2u = T2s - T2t; + T2v = T2r + T2u; + T2H = T2r - T2u; + T30 = TF - Tu; + T31 = T2U - T2R; + T32 = T30 + T31; + T34 = T31 - T30; + } + { + E T2A, T2F, T2I, T2J; + T2A = T2w + T2z; + T2F = T2B - T2E; + T2G = KP707106781 * (T2A + T2F); + T33 = KP707106781 * (T2F - T2A); + T2I = T2z - T2w; + T2J = T2B + T2E; + T2K = KP707106781 * (T2I - T2J); + T2Z = KP707106781 * (T2I + T2J); + } + iio[-WS(ios, 10)] = T2v - T2G; + rio[WS(ios, 10)] = T2Z - T32; + rio[WS(ios, 2)] = T2v + T2G; + iio[-WS(ios, 2)] = T2Z + T32; + iio[-WS(ios, 14)] = T2H - T2K; + rio[WS(ios, 14)] = T33 - T34; + rio[WS(ios, 6)] = T2H + T2K; + iio[-WS(ios, 6)] = T33 + T34; + } + { + E T2f, T2n, T3a, T3c, T2m, T3b, T2q, T35; + { + E T2b, T2e, T36, T39; + T2b = T1t + T1w; + T2e = KP707106781 * (T2c + T2d); + T2f = T2b + T2e; + T2n = T2b - T2e; + T36 = KP707106781 * (T1C + T1H); + T39 = T37 - T38; + T3a = T36 + T39; + T3c = T39 - T36; + } + { + E T2i, T2l, T2o, T2p; + T2i = FMA(KP382683432, T2g, KP923879532 * T2h); + T2l = FNMS(KP382683432, T2k, KP923879532 * T2j); + T2m = T2i + T2l; + T3b = T2l - T2i; + T2o = FNMS(KP382683432, T2h, KP923879532 * T2g); + T2p = FMA(KP923879532, T2k, KP382683432 * T2j); + T2q = T2o - T2p; + T35 = T2o + T2p; + } + iio[-WS(ios, 9)] = T2f - T2m; + rio[WS(ios, 9)] = T35 - T3a; + rio[WS(ios, 1)] = T2f + T2m; + iio[-WS(ios, 1)] = T35 + T3a; + iio[-WS(ios, 13)] = T2n - T2q; + rio[WS(ios, 13)] = T3b - T3c; + rio[WS(ios, 5)] = T2n + T2q; + iio[-WS(ios, 5)] = T3b + T3c; + } + { + E TH, T2L, T2W, T2Y, T1s, T2X, T2O, T2P; + { + E Tj, TG, T2Q, T2V; + Tj = T7 + Ti; + TG = Tu + TF; + TH = Tj + TG; + T2L = Tj - TG; + T2Q = T2s + T2t; + T2V = T2R + T2U; + T2W = T2Q + T2V; + T2Y = T2V - T2Q; + } + { + E T14, T1r, T2M, T2N; + T14 = TS + T13; + T1r = T1f + T1q; + T1s = T14 + T1r; + T2X = T1r - T14; + T2M = T2x + T2y; + T2N = T2C + T2D; + T2O = T2M - T2N; + T2P = T2M + T2N; + } + iio[-WS(ios, 8)] = TH - T1s; + rio[WS(ios, 8)] = T2P - T2W; + rio[0] = TH + T1s; + iio[0] = T2P + T2W; + iio[-WS(ios, 12)] = T2L - T2O; + rio[WS(ios, 12)] = T2X - T2Y; + rio[WS(ios, 4)] = T2L + T2O; + iio[-WS(ios, 4)] = T2X + T2Y; + } + } + return W; +} + +static const tw_instr twinstr[] = { + {TW_FULL, 0, 16}, + {TW_NEXT, 1, 0} +}; + +static const hc2hc_desc desc = { 16, "hf_16", twinstr, {136, 46, 38, 0}, &GENUS, 0, 0, 0 }; + +void X(codelet_hf_16) (planner *p) { + X(khc2hc_dit_register) (p, hf_16, &desc); +} diff --git a/src/fftw3/rdft/codelets/r2hc/hf_2.c b/src/fftw3/rdft/codelets/r2hc/hf_2.c new file mode 100644 index 0000000..7de094c --- /dev/null +++ b/src/fftw3/rdft/codelets/r2hc/hf_2.c @@ -0,0 +1,75 @@ +/* + * 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 21:56:51 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_hc2hc -compact -variables 4 -n 2 -dit -name hf_2 -include hf.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: hf_2.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: hf_2.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: hf_2.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + */ + +#include "hf.h" + +static const R *hf_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, T8, T6, T7; + T1 = rio[0]; + T8 = iio[-WS(ios, 1)]; + { + E T3, T5, T2, T4; + T3 = rio[WS(ios, 1)]; + T5 = iio[0]; + T2 = W[0]; + T4 = W[1]; + T6 = FMA(T2, T3, T4 * T5); + T7 = FNMS(T4, T3, T2 * T5); + } + iio[-WS(ios, 1)] = T1 - T6; + rio[WS(ios, 1)] = T7 - T8; + rio[0] = T1 + T6; + iio[0] = T7 + T8; + } + return W; +} + +static const tw_instr twinstr[] = { + {TW_FULL, 0, 2}, + {TW_NEXT, 1, 0} +}; + +static const hc2hc_desc desc = { 2, "hf_2", twinstr, {4, 2, 2, 0}, &GENUS, 0, 0, 0 }; + +void X(codelet_hf_2) (planner *p) { + X(khc2hc_dit_register) (p, hf_2, &desc); +} diff --git a/src/fftw3/rdft/codelets/r2hc/hf_3.c b/src/fftw3/rdft/codelets/r2hc/hf_3.c new file mode 100644 index 0000000..fce963f --- /dev/null +++ b/src/fftw3/rdft/codelets/r2hc/hf_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 21:56:51 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_hc2hc -compact -variables 4 -n 3 -dit -name hf_3 -include hf.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: hf_3.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: hf_3.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: hf_3.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + */ + +#include "hf.h" + +static const R *hf_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, Ti, T6, Te, Tb, Tf, Tc, Th; + T1 = rio[0]; + Ti = iio[-WS(ios, 2)]; + { + E T3, T5, T2, T4; + T3 = rio[WS(ios, 1)]; + T5 = iio[-WS(ios, 1)]; + T2 = W[0]; + T4 = W[1]; + T6 = FMA(T2, T3, T4 * T5); + Te = FNMS(T4, T3, T2 * T5); + } + { + E T8, Ta, T7, T9; + T8 = rio[WS(ios, 2)]; + Ta = iio[0]; + T7 = W[2]; + T9 = W[3]; + Tb = FMA(T7, T8, T9 * Ta); + Tf = FNMS(T9, T8, T7 * Ta); + } + Tc = T6 + Tb; + Th = Te + Tf; + rio[0] = T1 + Tc; + iio[0] = Th + Ti; + { + E Td, Tg, Tj, Tk; + Td = FNMS(KP500000000, Tc, T1); + Tg = KP866025403 * (Te - Tf); + iio[-WS(ios, 2)] = Td - Tg; + rio[WS(ios, 1)] = Td + Tg; + Tj = KP866025403 * (Tb - T6); + Tk = FNMS(KP500000000, Th, Ti); + rio[WS(ios, 2)] = Tj - Tk; + iio[-WS(ios, 1)] = Tj + Tk; + } + } + return W; +} + +static const tw_instr twinstr[] = { + {TW_FULL, 0, 3}, + {TW_NEXT, 1, 0} +}; + +static const hc2hc_desc desc = { 3, "hf_3", twinstr, {10, 6, 6, 0}, &GENUS, 0, 0, 0 }; + +void X(codelet_hf_3) (planner *p) { + X(khc2hc_dit_register) (p, hf_3, &desc); +} diff --git a/src/fftw3/rdft/codelets/r2hc/hf_32.c b/src/fftw3/rdft/codelets/r2hc/hf_32.c new file mode 100644 index 0000000..262ef43 --- /dev/null +++ b/src/fftw3/rdft/codelets/r2hc/hf_32.c @@ -0,0 +1,892 @@ +/* + * 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 21:57:08 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_hc2hc -compact -variables 4 -n 32 -dit -name hf_32 -include hf.h */ + +/* + * This function contains 434 FP additions, 208 FP multiplications, + * (or, 340 additions, 114 multiplications, 94 fused multiply/add), + * 96 stack variables, and 128 memory accesses + */ +/* + * Generator Id's : + * $Id: hf_32.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: hf_32.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: hf_32.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + */ + +#include "hf.h" + +static const R *hf_32(R *rio, R *iio, const R *W, stride ios, int m, int dist) +{ + 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 + 62) { + E Tj, T5F, T7C, T7Q, T35, T4T, T78, T7m, T2B, T67, T6e, T6O, T4b, T5d, T4s; + E T5g, TG, T7l, T5I, T73, T3a, T4U, T3f, T4V, T1Q, T61, T5Y, T6J, T3K, T59; + E T41, T56, T1r, T5P, T5S, T6F, T3x, T51, T3C, T52, T14, T5N, T5M, T6E, T3m; + E T4Y, T3r, T4Z, T2d, T5Z, T64, T6K, T3V, T57, T44, T5a, T2Y, T6f, T6a, T6P; + E T4m, T5h, T4v, T5e; + { + E T1, T76, T6, T75, Tc, T32, Th, T33; + T1 = rio[0]; + T76 = iio[-WS(ios, 31)]; + { + E T3, T5, T2, T4; + T3 = rio[WS(ios, 16)]; + T5 = iio[-WS(ios, 15)]; + T2 = W[30]; + T4 = W[31]; + T6 = FMA(T2, T3, T4 * T5); + T75 = FNMS(T4, T3, T2 * T5); + } + { + E T9, Tb, T8, Ta; + T9 = rio[WS(ios, 8)]; + Tb = iio[-WS(ios, 23)]; + T8 = W[14]; + Ta = W[15]; + Tc = FMA(T8, T9, Ta * Tb); + T32 = FNMS(Ta, T9, T8 * Tb); + } + { + E Te, Tg, Td, Tf; + Te = rio[WS(ios, 24)]; + Tg = iio[-WS(ios, 7)]; + Td = W[46]; + Tf = W[47]; + Th = FMA(Td, Te, Tf * Tg); + T33 = FNMS(Tf, Te, Td * Tg); + } + { + E T7, Ti, T7A, T7B; + T7 = T1 + T6; + Ti = Tc + Th; + Tj = T7 + Ti; + T5F = T7 - Ti; + T7A = T76 - T75; + T7B = Tc - Th; + T7C = T7A - T7B; + T7Q = T7B + T7A; + } + { + E T31, T34, T74, T77; + T31 = T1 - T6; + T34 = T32 - T33; + T35 = T31 - T34; + T4T = T31 + T34; + T74 = T32 + T33; + T77 = T75 + T76; + T78 = T74 + T77; + T7m = T77 - T74; + } + } + { + E T2j, T4o, T2z, T49, T2o, T4p, T2u, T48; + { + E T2g, T2i, T2f, T2h; + T2g = rio[WS(ios, 31)]; + T2i = iio[0]; + T2f = W[60]; + T2h = W[61]; + T2j = FMA(T2f, T2g, T2h * T2i); + T4o = FNMS(T2h, T2g, T2f * T2i); + } + { + E T2w, T2y, T2v, T2x; + T2w = rio[WS(ios, 23)]; + T2y = iio[-WS(ios, 8)]; + T2v = W[44]; + T2x = W[45]; + T2z = FMA(T2v, T2w, T2x * T2y); + T49 = FNMS(T2x, T2w, T2v * T2y); + } + { + E T2l, T2n, T2k, T2m; + T2l = rio[WS(ios, 15)]; + T2n = iio[-WS(ios, 16)]; + T2k = W[28]; + T2m = W[29]; + T2o = FMA(T2k, T2l, T2m * T2n); + T4p = FNMS(T2m, T2l, T2k * T2n); + } + { + E T2r, T2t, T2q, T2s; + T2r = rio[WS(ios, 7)]; + T2t = iio[-WS(ios, 24)]; + T2q = W[12]; + T2s = W[13]; + T2u = FMA(T2q, T2r, T2s * T2t); + T48 = FNMS(T2s, T2r, T2q * T2t); + } + { + E T2p, T2A, T6c, T6d; + T2p = T2j + T2o; + T2A = T2u + T2z; + T2B = T2p + T2A; + T67 = T2p - T2A; + T6c = T4o + T4p; + T6d = T48 + T49; + T6e = T6c - T6d; + T6O = T6c + T6d; + } + { + E T47, T4a, T4q, T4r; + T47 = T2j - T2o; + T4a = T48 - T49; + T4b = T47 - T4a; + T5d = T47 + T4a; + T4q = T4o - T4p; + T4r = T2u - T2z; + T4s = T4q + T4r; + T5g = T4q - T4r; + } + } + { + E To, T36, TE, T3d, Tt, T37, Tz, T3c; + { + E Tl, Tn, Tk, Tm; + Tl = rio[WS(ios, 4)]; + Tn = iio[-WS(ios, 27)]; + Tk = W[6]; + Tm = W[7]; + To = FMA(Tk, Tl, Tm * Tn); + T36 = FNMS(Tm, Tl, Tk * Tn); + } + { + E TB, TD, TA, TC; + TB = rio[WS(ios, 12)]; + TD = iio[-WS(ios, 19)]; + TA = W[22]; + TC = W[23]; + TE = FMA(TA, TB, TC * TD); + T3d = FNMS(TC, TB, TA * TD); + } + { + E Tq, Ts, Tp, Tr; + Tq = rio[WS(ios, 20)]; + Ts = iio[-WS(ios, 11)]; + Tp = W[38]; + Tr = W[39]; + Tt = FMA(Tp, Tq, Tr * Ts); + T37 = FNMS(Tr, Tq, Tp * Ts); + } + { + E Tw, Ty, Tv, Tx; + Tw = rio[WS(ios, 28)]; + Ty = iio[-WS(ios, 3)]; + Tv = W[54]; + Tx = W[55]; + Tz = FMA(Tv, Tw, Tx * Ty); + T3c = FNMS(Tx, Tw, Tv * Ty); + } + { + E Tu, TF, T5G, T5H; + Tu = To + Tt; + TF = Tz + TE; + TG = Tu + TF; + T7l = TF - Tu; + T5G = T36 + T37; + T5H = T3c + T3d; + T5I = T5G - T5H; + T73 = T5G + T5H; + } + { + E T38, T39, T3b, T3e; + T38 = T36 - T37; + T39 = To - Tt; + T3a = T38 - T39; + T4U = T39 + T38; + T3b = Tz - TE; + T3e = T3c - T3d; + T3f = T3b + T3e; + T4V = T3b - T3e; + } + } + { + E T1y, T3G, T1O, T3Z, T1D, T3H, T1J, T3Y; + { + E T1v, T1x, T1u, T1w; + T1v = rio[WS(ios, 1)]; + T1x = iio[-WS(ios, 30)]; + T1u = W[0]; + T1w = W[1]; + T1y = FMA(T1u, T1v, T1w * T1x); + T3G = FNMS(T1w, T1v, T1u * T1x); + } + { + E T1L, T1N, T1K, T1M; + T1L = rio[WS(ios, 25)]; + T1N = iio[-WS(ios, 6)]; + T1K = W[48]; + T1M = W[49]; + T1O = FMA(T1K, T1L, T1M * T1N); + T3Z = FNMS(T1M, T1L, T1K * T1N); + } + { + E T1A, T1C, T1z, T1B; + T1A = rio[WS(ios, 17)]; + T1C = iio[-WS(ios, 14)]; + T1z = W[32]; + T1B = W[33]; + T1D = FMA(T1z, T1A, T1B * T1C); + T3H = FNMS(T1B, T1A, T1z * T1C); + } + { + E T1G, T1I, T1F, T1H; + T1G = rio[WS(ios, 9)]; + T1I = iio[-WS(ios, 22)]; + T1F = W[16]; + T1H = W[17]; + T1J = FMA(T1F, T1G, T1H * T1I); + T3Y = FNMS(T1H, T1G, T1F * T1I); + } + { + E T1E, T1P, T5W, T5X; + T1E = T1y + T1D; + T1P = T1J + T1O; + T1Q = T1E + T1P; + T61 = T1E - T1P; + T5W = T3G + T3H; + T5X = T3Y + T3Z; + T5Y = T5W - T5X; + T6J = T5W + T5X; + } + { + E T3I, T3J, T3X, T40; + T3I = T3G - T3H; + T3J = T1J - T1O; + T3K = T3I + T3J; + T59 = T3I - T3J; + T3X = T1y - T1D; + T40 = T3Y - T3Z; + T41 = T3X - T40; + T56 = T3X + T40; + } + } + { + E T19, T3t, T1p, T3A, T1e, T3u, T1k, T3z; + { + E T16, T18, T15, T17; + T16 = rio[WS(ios, 30)]; + T18 = iio[-WS(ios, 1)]; + T15 = W[58]; + T17 = W[59]; + T19 = FMA(T15, T16, T17 * T18); + T3t = FNMS(T17, T16, T15 * T18); + } + { + E T1m, T1o, T1l, T1n; + T1m = rio[WS(ios, 22)]; + T1o = iio[-WS(ios, 9)]; + T1l = W[42]; + T1n = W[43]; + T1p = FMA(T1l, T1m, T1n * T1o); + T3A = FNMS(T1n, T1m, T1l * T1o); + } + { + E T1b, T1d, T1a, T1c; + T1b = rio[WS(ios, 14)]; + T1d = iio[-WS(ios, 17)]; + T1a = W[26]; + T1c = W[27]; + T1e = FMA(T1a, T1b, T1c * T1d); + T3u = FNMS(T1c, T1b, T1a * T1d); + } + { + E T1h, T1j, T1g, T1i; + T1h = rio[WS(ios, 6)]; + T1j = iio[-WS(ios, 25)]; + T1g = W[10]; + T1i = W[11]; + T1k = FMA(T1g, T1h, T1i * T1j); + T3z = FNMS(T1i, T1h, T1g * T1j); + } + { + E T1f, T1q, T5Q, T5R; + T1f = T19 + T1e; + T1q = T1k + T1p; + T1r = T1f + T1q; + T5P = T1f - T1q; + T5Q = T3t + T3u; + T5R = T3z + T3A; + T5S = T5Q - T5R; + T6F = T5Q + T5R; + } + { + E T3v, T3w, T3y, T3B; + T3v = T3t - T3u; + T3w = T1k - T1p; + T3x = T3v + T3w; + T51 = T3v - T3w; + T3y = T19 - T1e; + T3B = T3z - T3A; + T3C = T3y - T3B; + T52 = T3y + T3B; + } + } + { + E TM, T3i, T12, T3p, TR, T3j, TX, T3o; + { + E TJ, TL, TI, TK; + TJ = rio[WS(ios, 2)]; + TL = iio[-WS(ios, 29)]; + TI = W[2]; + TK = W[3]; + TM = FMA(TI, TJ, TK * TL); + T3i = FNMS(TK, TJ, TI * TL); + } + { + E TZ, T11, TY, T10; + TZ = rio[WS(ios, 26)]; + T11 = iio[-WS(ios, 5)]; + TY = W[50]; + T10 = W[51]; + T12 = FMA(TY, TZ, T10 * T11); + T3p = FNMS(T10, TZ, TY * T11); + } + { + E TO, TQ, TN, TP; + TO = rio[WS(ios, 18)]; + TQ = iio[-WS(ios, 13)]; + TN = W[34]; + TP = W[35]; + TR = FMA(TN, TO, TP * TQ); + T3j = FNMS(TP, TO, TN * TQ); + } + { + E TU, TW, TT, TV; + TU = rio[WS(ios, 10)]; + TW = iio[-WS(ios, 21)]; + TT = W[18]; + TV = W[19]; + TX = FMA(TT, TU, TV * TW); + T3o = FNMS(TV, TU, TT * TW); + } + { + E TS, T13, T5K, T5L; + TS = TM + TR; + T13 = TX + T12; + T14 = TS + T13; + T5N = TS - T13; + T5K = T3i + T3j; + T5L = T3o + T3p; + T5M = T5K - T5L; + T6E = T5K + T5L; + } + { + E T3k, T3l, T3n, T3q; + T3k = T3i - T3j; + T3l = TX - T12; + T3m = T3k + T3l; + T4Y = T3k - T3l; + T3n = TM - TR; + T3q = T3o - T3p; + T3r = T3n - T3q; + T4Z = T3n + T3q; + } + } + { + E T1V, T3R, T20, T3S, T3Q, T3T, T26, T3M, T2b, T3N, T3L, T3O; + { + E T1S, T1U, T1R, T1T; + T1S = rio[WS(ios, 5)]; + T1U = iio[-WS(ios, 26)]; + T1R = W[8]; + T1T = W[9]; + T1V = FMA(T1R, T1S, T1T * T1U); + T3R = FNMS(T1T, T1S, T1R * T1U); + } + { + E T1X, T1Z, T1W, T1Y; + T1X = rio[WS(ios, 21)]; + T1Z = iio[-WS(ios, 10)]; + T1W = W[40]; + T1Y = W[41]; + T20 = FMA(T1W, T1X, T1Y * T1Z); + T3S = FNMS(T1Y, T1X, T1W * T1Z); + } + T3Q = T1V - T20; + T3T = T3R - T3S; + { + E T23, T25, T22, T24; + T23 = rio[WS(ios, 29)]; + T25 = iio[-WS(ios, 2)]; + T22 = W[56]; + T24 = W[57]; + T26 = FMA(T22, T23, T24 * T25); + T3M = FNMS(T24, T23, T22 * T25); + } + { + E T28, T2a, T27, T29; + T28 = rio[WS(ios, 13)]; + T2a = iio[-WS(ios, 18)]; + T27 = W[24]; + T29 = W[25]; + T2b = FMA(T27, T28, T29 * T2a); + T3N = FNMS(T29, T28, T27 * T2a); + } + T3L = T26 - T2b; + T3O = T3M - T3N; + { + E T21, T2c, T62, T63; + T21 = T1V + T20; + T2c = T26 + T2b; + T2d = T21 + T2c; + T5Z = T2c - T21; + T62 = T3R + T3S; + T63 = T3M + T3N; + T64 = T62 - T63; + T6K = T62 + T63; + } + { + E T3P, T3U, T42, T43; + T3P = T3L - T3O; + T3U = T3Q + T3T; + T3V = KP707106781 * (T3P - T3U); + T57 = KP707106781 * (T3U + T3P); + T42 = T3T - T3Q; + T43 = T3L + T3O; + T44 = KP707106781 * (T42 - T43); + T5a = KP707106781 * (T42 + T43); + } + } + { + E T2G, T4c, T2L, T4d, T4e, T4f, T2R, T4i, T2W, T4j, T4h, T4k; + { + E T2D, T2F, T2C, T2E; + T2D = rio[WS(ios, 3)]; + T2F = iio[-WS(ios, 28)]; + T2C = W[4]; + T2E = W[5]; + T2G = FMA(T2C, T2D, T2E * T2F); + T4c = FNMS(T2E, T2D, T2C * T2F); + } + { + E T2I, T2K, T2H, T2J; + T2I = rio[WS(ios, 19)]; + T2K = iio[-WS(ios, 12)]; + T2H = W[36]; + T2J = W[37]; + T2L = FMA(T2H, T2I, T2J * T2K); + T4d = FNMS(T2J, T2I, T2H * T2K); + } + T4e = T4c - T4d; + T4f = T2G - T2L; + { + E T2O, T2Q, T2N, T2P; + T2O = rio[WS(ios, 27)]; + T2Q = iio[-WS(ios, 4)]; + T2N = W[52]; + T2P = W[53]; + T2R = FMA(T2N, T2O, T2P * T2Q); + T4i = FNMS(T2P, T2O, T2N * T2Q); + } + { + E T2T, T2V, T2S, T2U; + T2T = rio[WS(ios, 11)]; + T2V = iio[-WS(ios, 20)]; + T2S = W[20]; + T2U = W[21]; + T2W = FMA(T2S, T2T, T2U * T2V); + T4j = FNMS(T2U, T2T, T2S * T2V); + } + T4h = T2R - T2W; + T4k = T4i - T4j; + { + E T2M, T2X, T68, T69; + T2M = T2G + T2L; + T2X = T2R + T2W; + T2Y = T2M + T2X; + T6f = T2X - T2M; + T68 = T4c + T4d; + T69 = T4i + T4j; + T6a = T68 - T69; + T6P = T68 + T69; + } + { + E T4g, T4l, T4t, T4u; + T4g = T4e - T4f; + T4l = T4h + T4k; + T4m = KP707106781 * (T4g - T4l); + T5h = KP707106781 * (T4g + T4l); + T4t = T4h - T4k; + T4u = T4f + T4e; + T4v = KP707106781 * (T4t - T4u); + T5e = KP707106781 * (T4u + T4t); + } + } + { + E T1t, T6X, T7a, T7c, T30, T7b, T70, T71; + { + E TH, T1s, T72, T79; + TH = Tj + TG; + T1s = T14 + T1r; + T1t = TH + T1s; + T6X = TH - T1s; + T72 = T6E + T6F; + T79 = T73 + T78; + T7a = T72 + T79; + T7c = T79 - T72; + } + { + E T2e, T2Z, T6Y, T6Z; + T2e = T1Q + T2d; + T2Z = T2B + T2Y; + T30 = T2e + T2Z; + T7b = T2Z - T2e; + T6Y = T6J + T6K; + T6Z = T6O + T6P; + T70 = T6Y - T6Z; + T71 = T6Y + T6Z; + } + iio[-WS(ios, 16)] = T1t - T30; + rio[WS(ios, 16)] = T71 - T7a; + rio[0] = T1t + T30; + iio[0] = T71 + T7a; + iio[-WS(ios, 24)] = T6X - T70; + rio[WS(ios, 24)] = T7b - T7c; + rio[WS(ios, 8)] = T6X + T70; + iio[-WS(ios, 8)] = T7b + T7c; + } + { + E T6H, T6T, T7g, T7i, T6M, T6U, T6R, T6V; + { + E T6D, T6G, T7e, T7f; + T6D = Tj - TG; + T6G = T6E - T6F; + T6H = T6D + T6G; + T6T = T6D - T6G; + T7e = T1r - T14; + T7f = T78 - T73; + T7g = T7e + T7f; + T7i = T7f - T7e; + } + { + E T6I, T6L, T6N, T6Q; + T6I = T1Q - T2d; + T6L = T6J - T6K; + T6M = T6I + T6L; + T6U = T6L - T6I; + T6N = T2B - T2Y; + T6Q = T6O - T6P; + T6R = T6N - T6Q; + T6V = T6N + T6Q; + } + { + E T6S, T7d, T6W, T7h; + T6S = KP707106781 * (T6M + T6R); + iio[-WS(ios, 20)] = T6H - T6S; + rio[WS(ios, 4)] = T6H + T6S; + T7d = KP707106781 * (T6U + T6V); + rio[WS(ios, 20)] = T7d - T7g; + iio[-WS(ios, 4)] = T7d + T7g; + T6W = KP707106781 * (T6U - T6V); + iio[-WS(ios, 28)] = T6T - T6W; + rio[WS(ios, 12)] = T6T + T6W; + T7h = KP707106781 * (T6R - T6M); + rio[WS(ios, 28)] = T7h - T7i; + iio[-WS(ios, 12)] = T7h + T7i; + } + } + { + E T5J, T7n, T7t, T6n, T5U, T7k, T6x, T6B, T6q, T7s, T66, T6k, T6u, T6A, T6h; + E T6l; + { + E T5O, T5T, T60, T65; + T5J = T5F - T5I; + T7n = T7l + T7m; + T7t = T7m - T7l; + T6n = T5F + T5I; + T5O = T5M - T5N; + T5T = T5P + T5S; + T5U = KP707106781 * (T5O - T5T); + T7k = KP707106781 * (T5O + T5T); + { + E T6v, T6w, T6o, T6p; + T6v = T67 + T6a; + T6w = T6e + T6f; + T6x = FNMS(KP382683432, T6w, KP923879532 * T6v); + T6B = FMA(KP923879532, T6w, KP382683432 * T6v); + T6o = T5N + T5M; + T6p = T5P - T5S; + T6q = KP707106781 * (T6o + T6p); + T7s = KP707106781 * (T6p - T6o); + } + T60 = T5Y - T5Z; + T65 = T61 - T64; + T66 = FMA(KP923879532, T60, KP382683432 * T65); + T6k = FNMS(KP923879532, T65, KP382683432 * T60); + { + E T6s, T6t, T6b, T6g; + T6s = T5Y + T5Z; + T6t = T61 + T64; + T6u = FMA(KP382683432, T6s, KP923879532 * T6t); + T6A = FNMS(KP382683432, T6t, KP923879532 * T6s); + T6b = T67 - T6a; + T6g = T6e - T6f; + T6h = FNMS(KP923879532, T6g, KP382683432 * T6b); + T6l = FMA(KP382683432, T6g, KP923879532 * T6b); + } + } + { + E T5V, T6i, T7r, T7u; + T5V = T5J + T5U; + T6i = T66 + T6h; + iio[-WS(ios, 22)] = T5V - T6i; + rio[WS(ios, 6)] = T5V + T6i; + T7r = T6k + T6l; + T7u = T7s + T7t; + rio[WS(ios, 22)] = T7r - T7u; + iio[-WS(ios, 6)] = T7r + T7u; + } + { + E T6j, T6m, T7v, T7w; + T6j = T5J - T5U; + T6m = T6k - T6l; + iio[-WS(ios, 30)] = T6j - T6m; + rio[WS(ios, 14)] = T6j + T6m; + T7v = T6h - T66; + T7w = T7t - T7s; + rio[WS(ios, 30)] = T7v - T7w; + iio[-WS(ios, 14)] = T7v + T7w; + } + { + E T6r, T6y, T7j, T7o; + T6r = T6n + T6q; + T6y = T6u + T6x; + iio[-WS(ios, 18)] = T6r - T6y; + rio[WS(ios, 2)] = T6r + T6y; + T7j = T6A + T6B; + T7o = T7k + T7n; + rio[WS(ios, 18)] = T7j - T7o; + iio[-WS(ios, 2)] = T7j + T7o; + } + { + E T6z, T6C, T7p, T7q; + T6z = T6n - T6q; + T6C = T6A - T6B; + iio[-WS(ios, 26)] = T6z - T6C; + rio[WS(ios, 10)] = T6z + T6C; + T7p = T6x - T6u; + T7q = T7n - T7k; + rio[WS(ios, 26)] = T7p - T7q; + iio[-WS(ios, 10)] = T7p + T7q; + } + } + { + E T3h, T4D, T7R, T7X, T3E, T7O, T4N, T4R, T46, T4A, T4G, T7W, T4K, T4Q, T4x; + E T4B, T3g, T7P; + T3g = KP707106781 * (T3a - T3f); + T3h = T35 - T3g; + T4D = T35 + T3g; + T7P = KP707106781 * (T4V - T4U); + T7R = T7P + T7Q; + T7X = T7Q - T7P; + { + E T3s, T3D, T4L, T4M; + T3s = FNMS(KP923879532, T3r, KP382683432 * T3m); + T3D = FMA(KP382683432, T3x, KP923879532 * T3C); + T3E = T3s - T3D; + T7O = T3s + T3D; + T4L = T4b + T4m; + T4M = T4s + T4v; + T4N = FNMS(KP555570233, T4M, KP831469612 * T4L); + T4R = FMA(KP831469612, T4M, KP555570233 * T4L); + } + { + E T3W, T45, T4E, T4F; + T3W = T3K - T3V; + T45 = T41 - T44; + T46 = FMA(KP980785280, T3W, KP195090322 * T45); + T4A = FNMS(KP980785280, T45, KP195090322 * T3W); + T4E = FMA(KP923879532, T3m, KP382683432 * T3r); + T4F = FNMS(KP923879532, T3x, KP382683432 * T3C); + T4G = T4E + T4F; + T7W = T4F - T4E; + } + { + E T4I, T4J, T4n, T4w; + T4I = T3K + T3V; + T4J = T41 + T44; + T4K = FMA(KP555570233, T4I, KP831469612 * T4J); + T4Q = FNMS(KP555570233, T4J, KP831469612 * T4I); + T4n = T4b - T4m; + T4w = T4s - T4v; + T4x = FNMS(KP980785280, T4w, KP195090322 * T4n); + T4B = FMA(KP195090322, T4w, KP980785280 * T4n); + } + { + E T3F, T4y, T7V, T7Y; + T3F = T3h + T3E; + T4y = T46 + T4x; + iio[-WS(ios, 23)] = T3F - T4y; + rio[WS(ios, 7)] = T3F + T4y; + T7V = T4A + T4B; + T7Y = T7W + T7X; + rio[WS(ios, 23)] = T7V - T7Y; + iio[-WS(ios, 7)] = T7V + T7Y; + } + { + E T4z, T4C, T7Z, T80; + T4z = T3h - T3E; + T4C = T4A - T4B; + iio[-WS(ios, 31)] = T4z - T4C; + rio[WS(ios, 15)] = T4z + T4C; + T7Z = T4x - T46; + T80 = T7X - T7W; + rio[WS(ios, 31)] = T7Z - T80; + iio[-WS(ios, 15)] = T7Z + T80; + } + { + E T4H, T4O, T7N, T7S; + T4H = T4D + T4G; + T4O = T4K + T4N; + iio[-WS(ios, 19)] = T4H - T4O; + rio[WS(ios, 3)] = T4H + T4O; + T7N = T4Q + T4R; + T7S = T7O + T7R; + rio[WS(ios, 19)] = T7N - T7S; + iio[-WS(ios, 3)] = T7N + T7S; + } + { + E T4P, T4S, T7T, T7U; + T4P = T4D - T4G; + T4S = T4Q - T4R; + iio[-WS(ios, 27)] = T4P - T4S; + rio[WS(ios, 11)] = T4P + T4S; + T7T = T4N - T4K; + T7U = T7R - T7O; + rio[WS(ios, 27)] = T7T - T7U; + iio[-WS(ios, 11)] = T7T + T7U; + } + } + { + E T4X, T5p, T7D, T7J, T54, T7y, T5z, T5D, T5c, T5m, T5s, T7I, T5w, T5C, T5j; + E T5n, T4W, T7z; + T4W = KP707106781 * (T4U + T4V); + T4X = T4T - T4W; + T5p = T4T + T4W; + T7z = KP707106781 * (T3a + T3f); + T7D = T7z + T7C; + T7J = T7C - T7z; + { + E T50, T53, T5x, T5y; + T50 = FNMS(KP382683432, T4Z, KP923879532 * T4Y); + T53 = FMA(KP923879532, T51, KP382683432 * T52); + T54 = T50 - T53; + T7y = T50 + T53; + T5x = T5d + T5e; + T5y = T5g + T5h; + T5z = FNMS(KP195090322, T5y, KP980785280 * T5x); + T5D = FMA(KP195090322, T5x, KP980785280 * T5y); + } + { + E T58, T5b, T5q, T5r; + T58 = T56 - T57; + T5b = T59 - T5a; + T5c = FMA(KP555570233, T58, KP831469612 * T5b); + T5m = FNMS(KP831469612, T58, KP555570233 * T5b); + T5q = FMA(KP382683432, T4Y, KP923879532 * T4Z); + T5r = FNMS(KP382683432, T51, KP923879532 * T52); + T5s = T5q + T5r; + T7I = T5r - T5q; + } + { + E T5u, T5v, T5f, T5i; + T5u = T56 + T57; + T5v = T59 + T5a; + T5w = FMA(KP980785280, T5u, KP195090322 * T5v); + T5C = FNMS(KP195090322, T5u, KP980785280 * T5v); + T5f = T5d - T5e; + T5i = T5g - T5h; + T5j = FNMS(KP831469612, T5i, KP555570233 * T5f); + T5n = FMA(KP831469612, T5f, KP555570233 * T5i); + } + { + E T55, T5k, T7H, T7K; + T55 = T4X + T54; + T5k = T5c + T5j; + iio[-WS(ios, 21)] = T55 - T5k; + rio[WS(ios, 5)] = T55 + T5k; + T7H = T5m + T5n; + T7K = T7I + T7J; + rio[WS(ios, 21)] = T7H - T7K; + iio[-WS(ios, 5)] = T7H + T7K; + } + { + E T5l, T5o, T7L, T7M; + T5l = T4X - T54; + T5o = T5m - T5n; + iio[-WS(ios, 29)] = T5l - T5o; + rio[WS(ios, 13)] = T5l + T5o; + T7L = T5j - T5c; + T7M = T7J - T7I; + rio[WS(ios, 29)] = T7L - T7M; + iio[-WS(ios, 13)] = T7L + T7M; + } + { + E T5t, T5A, T7x, T7E; + T5t = T5p + T5s; + T5A = T5w + T5z; + iio[-WS(ios, 17)] = T5t - T5A; + rio[WS(ios, 1)] = T5t + T5A; + T7x = T5C + T5D; + T7E = T7y + T7D; + rio[WS(ios, 17)] = T7x - T7E; + iio[-WS(ios, 1)] = T7x + T7E; + } + { + E T5B, T5E, T7F, T7G; + T5B = T5p - T5s; + T5E = T5C - T5D; + iio[-WS(ios, 25)] = T5B - T5E; + rio[WS(ios, 9)] = T5B + T5E; + T7F = T5z - T5w; + T7G = T7D - T7y; + rio[WS(ios, 25)] = T7F - T7G; + iio[-WS(ios, 9)] = T7F + T7G; + } + } + } + return W; +} + +static const tw_instr twinstr[] = { + {TW_FULL, 0, 32}, + {TW_NEXT, 1, 0} +}; + +static const hc2hc_desc desc = { 32, "hf_32", twinstr, {340, 114, 94, 0}, &GENUS, 0, 0, 0 }; + +void X(codelet_hf_32) (planner *p) { + X(khc2hc_dit_register) (p, hf_32, &desc); +} diff --git a/src/fftw3/rdft/codelets/r2hc/hf_4.c b/src/fftw3/rdft/codelets/r2hc/hf_4.c new file mode 100644 index 0000000..f4468dd --- /dev/null +++ b/src/fftw3/rdft/codelets/r2hc/hf_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 21:56:51 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_hc2hc -compact -variables 4 -n 4 -dit -name hf_4 -include hf.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: hf_4.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: hf_4.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: hf_4.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + */ + +#include "hf.h" + +static const R *hf_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 T1, Th, Tl, Tp, T6, To, Tc, Tk; + T1 = rio[0]; + { + E Te, Tg, Td, Tf; + Te = rio[WS(ios, 3)]; + Tg = iio[0]; + Td = W[4]; + Tf = W[5]; + Th = FMA(Td, Te, Tf * Tg); + Tl = FNMS(Tf, Te, Td * Tg); + } + Tp = iio[-WS(ios, 3)]; + { + E T3, T5, T2, T4; + T3 = rio[WS(ios, 2)]; + T5 = iio[-WS(ios, 1)]; + T2 = W[2]; + T4 = W[3]; + T6 = FMA(T2, T3, T4 * T5); + To = FNMS(T4, T3, T2 * T5); + } + { + E T9, Tb, T8, Ta; + T9 = rio[WS(ios, 1)]; + Tb = iio[-WS(ios, 2)]; + T8 = W[0]; + Ta = W[1]; + Tc = FMA(T8, T9, Ta * Tb); + Tk = FNMS(Ta, T9, T8 * Tb); + } + { + E T7, Ti, Tn, Tq; + T7 = T1 + T6; + Ti = Tc + Th; + iio[-WS(ios, 2)] = T7 - Ti; + rio[0] = T7 + Ti; + Tn = Tk + Tl; + Tq = To + Tp; + rio[WS(ios, 2)] = Tn - Tq; + iio[0] = Tn + Tq; + } + { + E Tj, Tm, Tr, Ts; + Tj = T1 - T6; + Tm = Tk - Tl; + iio[-WS(ios, 3)] = Tj - Tm; + rio[WS(ios, 1)] = Tj + Tm; + Tr = Th - Tc; + Ts = Tp - To; + rio[WS(ios, 3)] = Tr - Ts; + iio[-WS(ios, 1)] = Tr + Ts; + } + } + return W; +} + +static const tw_instr twinstr[] = { + {TW_FULL, 0, 4}, + {TW_NEXT, 1, 0} +}; + +static const hc2hc_desc desc = { 4, "hf_4", twinstr, {16, 6, 6, 0}, &GENUS, 0, 0, 0 }; + +void X(codelet_hf_4) (planner *p) { + X(khc2hc_dit_register) (p, hf_4, &desc); +} diff --git a/src/fftw3/rdft/codelets/r2hc/hf_5.c b/src/fftw3/rdft/codelets/r2hc/hf_5.c new file mode 100644 index 0000000..2f02461 --- /dev/null +++ b/src/fftw3/rdft/codelets/r2hc/hf_5.c @@ -0,0 +1,143 @@ +/* + * 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 21:56:52 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_hc2hc -compact -variables 4 -n 5 -dit -name hf_5 -include hf.h */ + +/* + * This function contains 40 FP additions, 28 FP multiplications, + * (or, 26 additions, 14 multiplications, 14 fused multiply/add), + * 29 stack variables, and 20 memory accesses + */ +/* + * Generator Id's : + * $Id: hf_5.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: hf_5.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: hf_5.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + */ + +#include "hf.h" + +static const R *hf_5(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); + int i; + for (i = m - 2; i > 0; i = i - 2, rio = rio + dist, iio = iio - dist, W = W + 8) { + E T1, TE, Tu, Tx, TG, TF, TB, TC, TD, Tc, Tn, To; + T1 = rio[0]; + TE = iio[-WS(ios, 4)]; + { + E T6, Ts, Tm, Tw, Tb, Tt, Th, Tv; + { + E T3, T5, T2, T4; + T3 = rio[WS(ios, 1)]; + T5 = iio[-WS(ios, 3)]; + T2 = W[0]; + T4 = W[1]; + T6 = FMA(T2, T3, T4 * T5); + Ts = FNMS(T4, T3, T2 * T5); + } + { + E Tj, Tl, Ti, Tk; + Tj = rio[WS(ios, 3)]; + Tl = iio[-WS(ios, 1)]; + Ti = W[4]; + Tk = W[5]; + Tm = FMA(Ti, Tj, Tk * Tl); + Tw = FNMS(Tk, Tj, Ti * Tl); + } + { + E T8, Ta, T7, T9; + T8 = rio[WS(ios, 4)]; + Ta = iio[0]; + T7 = W[6]; + T9 = W[7]; + Tb = FMA(T7, T8, T9 * Ta); + Tt = FNMS(T9, T8, T7 * Ta); + } + { + E Te, Tg, Td, Tf; + Te = rio[WS(ios, 2)]; + Tg = iio[-WS(ios, 2)]; + Td = W[2]; + Tf = W[3]; + Th = FMA(Td, Te, Tf * Tg); + Tv = FNMS(Tf, Te, Td * Tg); + } + Tu = Ts - Tt; + Tx = Tv - Tw; + TG = Th - Tm; + TF = Tb - T6; + TB = Ts + Tt; + TC = Tv + Tw; + TD = TB + TC; + Tc = T6 + Tb; + Tn = Th + Tm; + To = Tc + Tn; + } + rio[0] = T1 + To; + iio[0] = TD + TE; + { + E Ty, TA, Tr, Tz, Tp, Tq; + Ty = FMA(KP951056516, Tu, KP587785252 * Tx); + TA = FNMS(KP587785252, Tu, KP951056516 * Tx); + Tp = KP559016994 * (Tc - Tn); + Tq = FNMS(KP250000000, To, T1); + Tr = Tp + Tq; + Tz = Tq - Tp; + iio[-WS(ios, 4)] = Tr - Ty; + iio[-WS(ios, 3)] = Tz + TA; + rio[WS(ios, 1)] = Tr + Ty; + rio[WS(ios, 2)] = Tz - TA; + } + { + E TH, TL, TK, TM, TI, TJ; + TH = FNMS(KP587785252, TG, KP951056516 * TF); + TL = FMA(KP587785252, TF, KP951056516 * TG); + TI = KP559016994 * (TB - TC); + TJ = FNMS(KP250000000, TD, TE); + TK = TI + TJ; + TM = TJ - TI; + rio[WS(ios, 4)] = TH - TK; + iio[-WS(ios, 2)] = TL + TM; + iio[-WS(ios, 1)] = TH + TK; + rio[WS(ios, 3)] = TL - TM; + } + } + return W; +} + +static const tw_instr twinstr[] = { + {TW_FULL, 0, 5}, + {TW_NEXT, 1, 0} +}; + +static const hc2hc_desc desc = { 5, "hf_5", twinstr, {26, 14, 14, 0}, &GENUS, 0, 0, 0 }; + +void X(codelet_hf_5) (planner *p) { + X(khc2hc_dit_register) (p, hf_5, &desc); +} diff --git a/src/fftw3/rdft/codelets/r2hc/hf_6.c b/src/fftw3/rdft/codelets/r2hc/hf_6.c new file mode 100644 index 0000000..e4c9f8d --- /dev/null +++ b/src/fftw3/rdft/codelets/r2hc/hf_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 21:56:54 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_hc2hc -compact -variables 4 -n 6 -dit -name hf_6 -include hf.h */ + +/* + * This function contains 46 FP additions, 28 FP multiplications, + * (or, 32 additions, 14 multiplications, 14 fused multiply/add), + * 23 stack variables, and 24 memory accesses + */ +/* + * Generator Id's : + * $Id: hf_6.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: hf_6.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: hf_6.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + */ + +#include "hf.h" + +static const R *hf_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 T7, TS, Tv, TO, Ti, TI, Tw, TC, Tt, TJ, Tx, TF; + { + E T1, TN, T6, TM; + T1 = rio[0]; + TN = iio[-WS(ios, 5)]; + { + E T3, T5, T2, T4; + T3 = rio[WS(ios, 3)]; + T5 = iio[-WS(ios, 2)]; + T2 = W[4]; + T4 = W[5]; + T6 = FMA(T2, T3, T4 * T5); + TM = FNMS(T4, T3, T2 * T5); + } + T7 = T1 - T6; + TS = TN - TM; + Tv = T1 + T6; + TO = TM + TN; + } + { + E Tc, TA, Th, TB; + { + E T9, Tb, T8, Ta; + T9 = rio[WS(ios, 2)]; + Tb = iio[-WS(ios, 3)]; + T8 = W[2]; + Ta = W[3]; + Tc = FMA(T8, T9, Ta * Tb); + TA = FNMS(Ta, T9, T8 * Tb); + } + { + E Te, Tg, Td, Tf; + Te = rio[WS(ios, 5)]; + Tg = iio[0]; + Td = W[8]; + Tf = W[9]; + Th = FMA(Td, Te, Tf * Tg); + TB = FNMS(Tf, Te, Td * Tg); + } + Ti = Tc - Th; + TI = TA - TB; + Tw = Tc + Th; + TC = TA + TB; + } + { + E Tn, TD, Ts, TE; + { + E Tk, Tm, Tj, Tl; + Tk = rio[WS(ios, 4)]; + Tm = iio[-WS(ios, 1)]; + Tj = W[6]; + Tl = W[7]; + Tn = FMA(Tj, Tk, Tl * Tm); + TD = FNMS(Tl, Tk, Tj * Tm); + } + { + E Tp, Tr, To, Tq; + Tp = rio[WS(ios, 1)]; + Tr = iio[-WS(ios, 4)]; + To = W[0]; + Tq = W[1]; + Ts = FMA(To, Tp, Tq * Tr); + TE = FNMS(Tq, Tp, To * Tr); + } + Tt = Tn - Ts; + TJ = TE - TD; + Tx = Tn + Ts; + TF = TD + TE; + } + { + E TK, Tu, TH, TT, TR, TU; + TK = KP866025403 * (TI + TJ); + Tu = Ti + Tt; + TH = FNMS(KP500000000, Tu, T7); + iio[-WS(ios, 3)] = T7 + Tu; + rio[WS(ios, 1)] = TH + TK; + iio[-WS(ios, 5)] = TH - TK; + TT = KP866025403 * (Tt - Ti); + TR = TJ - TI; + TU = FMA(KP500000000, TR, TS); + rio[WS(ios, 3)] = TR - TS; + iio[-WS(ios, 1)] = TT + TU; + rio[WS(ios, 5)] = TT - TU; + } + { + E TG, Ty, Tz, TP, TL, TQ; + TG = KP866025403 * (TC - TF); + Ty = Tw + Tx; + Tz = FNMS(KP500000000, Ty, Tv); + rio[0] = Tv + Ty; + iio[-WS(ios, 4)] = Tz + TG; + rio[WS(ios, 2)] = Tz - TG; + TP = KP866025403 * (Tw - Tx); + TL = TC + TF; + TQ = FNMS(KP500000000, TL, TO); + iio[0] = TL + TO; + iio[-WS(ios, 2)] = TP + TQ; + rio[WS(ios, 4)] = TP - TQ; + } + } + return W; +} + +static const tw_instr twinstr[] = { + {TW_FULL, 0, 6}, + {TW_NEXT, 1, 0} +}; + +static const hc2hc_desc desc = { 6, "hf_6", twinstr, {32, 14, 14, 0}, &GENUS, 0, 0, 0 }; + +void X(codelet_hf_6) (planner *p) { + X(khc2hc_dit_register) (p, hf_6, &desc); +} diff --git a/src/fftw3/rdft/codelets/r2hc/hf_64.c b/src/fftw3/rdft/codelets/r2hc/hf_64.c new file mode 100644 index 0000000..3e99d63 --- /dev/null +++ b/src/fftw3/rdft/codelets/r2hc/hf_64.c @@ -0,0 +1,2001 @@ +/* + * 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 21:57:11 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_hc2hc -compact -variables 4 -n 64 -dit -name hf_64 -include hf.h */ + +/* + * This function contains 1038 FP additions, 500 FP multiplications, + * (or, 808 additions, 270 multiplications, 230 fused multiply/add), + * 176 stack variables, and 256 memory accesses + */ +/* + * Generator Id's : + * $Id: hf_64.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: hf_64.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: hf_64.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + */ + +#include "hf.h" + +static const R *hf_64(R *rio, R *iio, const R *W, stride ios, int m, int dist) +{ + DK(KP471396736, +0.471396736825997648556387625905254377657460319); + DK(KP881921264, +0.881921264348355029712756863660388349508442621); + DK(KP290284677, +0.290284677254462367636192375817395274691476278); + DK(KP956940335, +0.956940335732208864935797886980269969482849206); + DK(KP634393284, +0.634393284163645498215171613225493370675687095); + DK(KP773010453, +0.773010453362736960810906609758469800971041293); + DK(KP098017140, +0.098017140329560601994195563888641845861136673); + DK(KP995184726, +0.995184726672196886244836953109479921575474869); + DK(KP555570233, +0.555570233019602224742830813948532874374937191); + DK(KP831469612, +0.831469612302545237078788377617905756738560812); + DK(KP980785280, +0.980785280403230449126182236134239036973933731); + DK(KP195090322, +0.195090322016128267848284868477022240927691618); + DK(KP923879532, +0.923879532511286756128183189396788286822416626); + DK(KP382683432, +0.382683432365089771728459984030398866761344562); + 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 Tj, TcL, ThT, Tin, T6b, Taz, TgT, Thn, TG, Thm, TcO, TgO, T6m, ThQ, TaC; + E Tim, T14, Tfq, T6y, T9O, TaG, Tc0, TcU, TeE, T1r, Tfr, T6J, T9P, TaJ, Tc1; + E TcZ, TeF, T1Q, T2d, Tfx, Tfu, Tfv, Tfw, T6Q, TaM, Tdb, TeJ, T71, TaQ, T7a; + E TaN, Td6, TeI, T77, TaP, T2B, T2Y, Tfz, TfA, TfB, TfC, T7h, TaW, Tdm, TeM; + E T7s, TaU, T7B, TaX, Tdh, TeL, T7y, TaT, T3M, TfL, TdL, TeQ, TfI, Tgt, T7K; + E Tb2, T7V, Tbe, T8s, Tb3, Tdu, TeT, T8p, Tbd, T5j, TfR, Tec, Tf0, TfY, Tgy; + E T8D, Tbl, T8O, Tbx, T9l, Tbm, TdV, TeX, T9i, Tbw, T64, TfZ, Te5, Ted, TfU; + E Tgz, T90, T9o, T9b, T9n, Tbt, Tbz, Te0, Tee, Tbq, TbA, T4x, TfJ, TdE, TdM; + E TfO, Tgu, T87, T8v, T8i, T8u, Tba, Tbg, Tdz, TdN, Tb7, Tbh; + { + E T1, TgR, T6, TgQ, Tc, T68, Th, T69; + T1 = rio[0]; + TgR = iio[-WS(ios, 63)]; + { + E T3, T5, T2, T4; + T3 = rio[WS(ios, 32)]; + T5 = iio[-WS(ios, 31)]; + T2 = W[62]; + T4 = W[63]; + T6 = FMA(T2, T3, T4 * T5); + TgQ = FNMS(T4, T3, T2 * T5); + } + { + E T9, Tb, T8, Ta; + T9 = rio[WS(ios, 16)]; + Tb = iio[-WS(ios, 47)]; + T8 = W[30]; + Ta = W[31]; + Tc = FMA(T8, T9, Ta * Tb); + T68 = FNMS(Ta, T9, T8 * Tb); + } + { + E Te, Tg, Td, Tf; + Te = rio[WS(ios, 48)]; + Tg = iio[-WS(ios, 15)]; + Td = W[94]; + Tf = W[95]; + Th = FMA(Td, Te, Tf * Tg); + T69 = FNMS(Tf, Te, Td * Tg); + } + { + E T7, Ti, ThR, ThS; + T7 = T1 + T6; + Ti = Tc + Th; + Tj = T7 + Ti; + TcL = T7 - Ti; + ThR = TgR - TgQ; + ThS = Tc - Th; + ThT = ThR - ThS; + Tin = ThS + ThR; + } + { + E T67, T6a, TgP, TgS; + T67 = T1 - T6; + T6a = T68 - T69; + T6b = T67 - T6a; + Taz = T67 + T6a; + TgP = T68 + T69; + TgS = TgQ + TgR; + TgT = TgP + TgS; + Thn = TgS - TgP; + } + } + { + E To, T6c, Tt, T6d, T6e, T6f, Tz, T6i, TE, T6j, T6h, T6k; + { + E Tl, Tn, Tk, Tm; + Tl = rio[WS(ios, 8)]; + Tn = iio[-WS(ios, 55)]; + Tk = W[14]; + Tm = W[15]; + To = FMA(Tk, Tl, Tm * Tn); + T6c = FNMS(Tm, Tl, Tk * Tn); + } + { + E Tq, Ts, Tp, Tr; + Tq = rio[WS(ios, 40)]; + Ts = iio[-WS(ios, 23)]; + Tp = W[78]; + Tr = W[79]; + Tt = FMA(Tp, Tq, Tr * Ts); + T6d = FNMS(Tr, Tq, Tp * Ts); + } + T6e = T6c - T6d; + T6f = To - Tt; + { + E Tw, Ty, Tv, Tx; + Tw = rio[WS(ios, 56)]; + Ty = iio[-WS(ios, 7)]; + Tv = W[110]; + Tx = W[111]; + Tz = FMA(Tv, Tw, Tx * Ty); + T6i = FNMS(Tx, Tw, Tv * Ty); + } + { + E TB, TD, TA, TC; + TB = rio[WS(ios, 24)]; + TD = iio[-WS(ios, 39)]; + TA = W[46]; + TC = W[47]; + TE = FMA(TA, TB, TC * TD); + T6j = FNMS(TC, TB, TA * TD); + } + T6h = Tz - TE; + T6k = T6i - T6j; + { + E Tu, TF, TcM, TcN; + Tu = To + Tt; + TF = Tz + TE; + TG = Tu + TF; + Thm = TF - Tu; + TcM = T6c + T6d; + TcN = T6i + T6j; + TcO = TcM - TcN; + TgO = TcM + TcN; + } + { + E T6g, T6l, TaA, TaB; + T6g = T6e - T6f; + T6l = T6h + T6k; + T6m = KP707106781 * (T6g - T6l); + ThQ = KP707106781 * (T6g + T6l); + TaA = T6f + T6e; + TaB = T6h - T6k; + TaC = KP707106781 * (TaA + TaB); + Tim = KP707106781 * (TaB - TaA); + } + } + { + E TS, TcQ, T6q, T6t, T13, TcR, T6r, T6w, T6s, T6x; + { + E TM, T6o, TR, T6p; + { + E TJ, TL, TI, TK; + TJ = rio[WS(ios, 4)]; + TL = iio[-WS(ios, 59)]; + TI = W[6]; + TK = W[7]; + TM = FMA(TI, TJ, TK * TL); + T6o = FNMS(TK, TJ, TI * TL); + } + { + E TO, TQ, TN, TP; + TO = rio[WS(ios, 36)]; + TQ = iio[-WS(ios, 27)]; + TN = W[70]; + TP = W[71]; + TR = FMA(TN, TO, TP * TQ); + T6p = FNMS(TP, TO, TN * TQ); + } + TS = TM + TR; + TcQ = T6o + T6p; + T6q = T6o - T6p; + T6t = TM - TR; + } + { + E TX, T6u, T12, T6v; + { + E TU, TW, TT, TV; + TU = rio[WS(ios, 20)]; + TW = iio[-WS(ios, 43)]; + TT = W[38]; + TV = W[39]; + TX = FMA(TT, TU, TV * TW); + T6u = FNMS(TV, TU, TT * TW); + } + { + E TZ, T11, TY, T10; + TZ = rio[WS(ios, 52)]; + T11 = iio[-WS(ios, 11)]; + TY = W[102]; + T10 = W[103]; + T12 = FMA(TY, TZ, T10 * T11); + T6v = FNMS(T10, TZ, TY * T11); + } + T13 = TX + T12; + TcR = T6u + T6v; + T6r = TX - T12; + T6w = T6u - T6v; + } + T14 = TS + T13; + Tfq = TcQ + TcR; + T6s = T6q + T6r; + T6x = T6t - T6w; + T6y = FNMS(KP923879532, T6x, KP382683432 * T6s); + T9O = FMA(KP923879532, T6s, KP382683432 * T6x); + { + E TaE, TaF, TcS, TcT; + TaE = T6q - T6r; + TaF = T6t + T6w; + TaG = FNMS(KP382683432, TaF, KP923879532 * TaE); + Tc0 = FMA(KP382683432, TaE, KP923879532 * TaF); + TcS = TcQ - TcR; + TcT = TS - T13; + TcU = TcS - TcT; + TeE = TcT + TcS; + } + } + { + E T1f, TcW, T6B, T6E, T1q, TcX, T6C, T6H, T6D, T6I; + { + E T19, T6z, T1e, T6A; + { + E T16, T18, T15, T17; + T16 = rio[WS(ios, 60)]; + T18 = iio[-WS(ios, 3)]; + T15 = W[118]; + T17 = W[119]; + T19 = FMA(T15, T16, T17 * T18); + T6z = FNMS(T17, T16, T15 * T18); + } + { + E T1b, T1d, T1a, T1c; + T1b = rio[WS(ios, 28)]; + T1d = iio[-WS(ios, 35)]; + T1a = W[54]; + T1c = W[55]; + T1e = FMA(T1a, T1b, T1c * T1d); + T6A = FNMS(T1c, T1b, T1a * T1d); + } + T1f = T19 + T1e; + TcW = T6z + T6A; + T6B = T6z - T6A; + T6E = T19 - T1e; + } + { + E T1k, T6F, T1p, T6G; + { + E T1h, T1j, T1g, T1i; + T1h = rio[WS(ios, 12)]; + T1j = iio[-WS(ios, 51)]; + T1g = W[22]; + T1i = W[23]; + T1k = FMA(T1g, T1h, T1i * T1j); + T6F = FNMS(T1i, T1h, T1g * T1j); + } + { + E T1m, T1o, T1l, T1n; + T1m = rio[WS(ios, 44)]; + T1o = iio[-WS(ios, 19)]; + T1l = W[86]; + T1n = W[87]; + T1p = FMA(T1l, T1m, T1n * T1o); + T6G = FNMS(T1n, T1m, T1l * T1o); + } + T1q = T1k + T1p; + TcX = T6F + T6G; + T6C = T1k - T1p; + T6H = T6F - T6G; + } + T1r = T1f + T1q; + Tfr = TcW + TcX; + T6D = T6B + T6C; + T6I = T6E - T6H; + T6J = FMA(KP382683432, T6D, KP923879532 * T6I); + T9P = FNMS(KP923879532, T6D, KP382683432 * T6I); + { + E TaH, TaI, TcV, TcY; + TaH = T6B - T6C; + TaI = T6E + T6H; + TaJ = FMA(KP923879532, TaH, KP382683432 * TaI); + Tc1 = FNMS(KP382683432, TaH, KP923879532 * TaI); + TcV = T1f - T1q; + TcY = TcW - TcX; + TcZ = TcV + TcY; + TeF = TcV - TcY; + } + } + { + E T1y, T6M, T1D, T6N, T1E, Td2, T1J, T74, T1O, T75, T1P, Td3, T21, Td8, T6W; + E T6Z, T2c, Td9, T6R, T6U; + { + E T1v, T1x, T1u, T1w; + T1v = rio[WS(ios, 2)]; + T1x = iio[-WS(ios, 61)]; + T1u = W[2]; + T1w = W[3]; + T1y = FMA(T1u, T1v, T1w * T1x); + T6M = FNMS(T1w, T1v, T1u * T1x); + } + { + E T1A, T1C, T1z, T1B; + T1A = rio[WS(ios, 34)]; + T1C = iio[-WS(ios, 29)]; + T1z = W[66]; + T1B = W[67]; + T1D = FMA(T1z, T1A, T1B * T1C); + T6N = FNMS(T1B, T1A, T1z * T1C); + } + T1E = T1y + T1D; + Td2 = T6M + T6N; + { + E T1G, T1I, T1F, T1H; + T1G = rio[WS(ios, 18)]; + T1I = iio[-WS(ios, 45)]; + T1F = W[34]; + T1H = W[35]; + T1J = FMA(T1F, T1G, T1H * T1I); + T74 = FNMS(T1H, T1G, T1F * T1I); + } + { + E T1L, T1N, T1K, T1M; + T1L = rio[WS(ios, 50)]; + T1N = iio[-WS(ios, 13)]; + T1K = W[98]; + T1M = W[99]; + T1O = FMA(T1K, T1L, T1M * T1N); + T75 = FNMS(T1M, T1L, T1K * T1N); + } + T1P = T1J + T1O; + Td3 = T74 + T75; + { + E T1V, T6X, T20, T6Y; + { + E T1S, T1U, T1R, T1T; + T1S = rio[WS(ios, 10)]; + T1U = iio[-WS(ios, 53)]; + T1R = W[18]; + T1T = W[19]; + T1V = FMA(T1R, T1S, T1T * T1U); + T6X = FNMS(T1T, T1S, T1R * T1U); + } + { + E T1X, T1Z, T1W, T1Y; + T1X = rio[WS(ios, 42)]; + T1Z = iio[-WS(ios, 21)]; + T1W = W[82]; + T1Y = W[83]; + T20 = FMA(T1W, T1X, T1Y * T1Z); + T6Y = FNMS(T1Y, T1X, T1W * T1Z); + } + T21 = T1V + T20; + Td8 = T6X + T6Y; + T6W = T1V - T20; + T6Z = T6X - T6Y; + } + { + E T26, T6S, T2b, T6T; + { + E T23, T25, T22, T24; + T23 = rio[WS(ios, 58)]; + T25 = iio[-WS(ios, 5)]; + T22 = W[114]; + T24 = W[115]; + T26 = FMA(T22, T23, T24 * T25); + T6S = FNMS(T24, T23, T22 * T25); + } + { + E T28, T2a, T27, T29; + T28 = rio[WS(ios, 26)]; + T2a = iio[-WS(ios, 37)]; + T27 = W[50]; + T29 = W[51]; + T2b = FMA(T27, T28, T29 * T2a); + T6T = FNMS(T29, T28, T27 * T2a); + } + T2c = T26 + T2b; + Td9 = T6S + T6T; + T6R = T26 - T2b; + T6U = T6S - T6T; + } + T1Q = T1E + T1P; + T2d = T21 + T2c; + Tfx = T1Q - T2d; + Tfu = Td2 + Td3; + Tfv = Td8 + Td9; + Tfw = Tfu - Tfv; + { + E T6O, T6P, Td7, Tda; + T6O = T6M - T6N; + T6P = T1J - T1O; + T6Q = T6O + T6P; + TaM = T6O - T6P; + Td7 = T1E - T1P; + Tda = Td8 - Td9; + Tdb = Td7 - Tda; + TeJ = Td7 + Tda; + } + { + E T6V, T70, T78, T79; + T6V = T6R - T6U; + T70 = T6W + T6Z; + T71 = KP707106781 * (T6V - T70); + TaQ = KP707106781 * (T70 + T6V); + T78 = T6Z - T6W; + T79 = T6R + T6U; + T7a = KP707106781 * (T78 - T79); + TaN = KP707106781 * (T78 + T79); + } + { + E Td4, Td5, T73, T76; + Td4 = Td2 - Td3; + Td5 = T2c - T21; + Td6 = Td4 - Td5; + TeI = Td4 + Td5; + T73 = T1y - T1D; + T76 = T74 - T75; + T77 = T73 - T76; + TaP = T73 + T76; + } + } + { + E T2j, T7d, T2o, T7e, T2p, Tdd, T2u, T7v, T2z, T7w, T2A, Tde, T2M, Tdj, T7n; + E T7q, T2X, Tdk, T7i, T7l; + { + E T2g, T2i, T2f, T2h; + T2g = rio[WS(ios, 62)]; + T2i = iio[-WS(ios, 1)]; + T2f = W[122]; + T2h = W[123]; + T2j = FMA(T2f, T2g, T2h * T2i); + T7d = FNMS(T2h, T2g, T2f * T2i); + } + { + E T2l, T2n, T2k, T2m; + T2l = rio[WS(ios, 30)]; + T2n = iio[-WS(ios, 33)]; + T2k = W[58]; + T2m = W[59]; + T2o = FMA(T2k, T2l, T2m * T2n); + T7e = FNMS(T2m, T2l, T2k * T2n); + } + T2p = T2j + T2o; + Tdd = T7d + T7e; + { + E T2r, T2t, T2q, T2s; + T2r = rio[WS(ios, 14)]; + T2t = iio[-WS(ios, 49)]; + T2q = W[26]; + T2s = W[27]; + T2u = FMA(T2q, T2r, T2s * T2t); + T7v = FNMS(T2s, T2r, T2q * T2t); + } + { + E T2w, T2y, T2v, T2x; + T2w = rio[WS(ios, 46)]; + T2y = iio[-WS(ios, 17)]; + T2v = W[90]; + T2x = W[91]; + T2z = FMA(T2v, T2w, T2x * T2y); + T7w = FNMS(T2x, T2w, T2v * T2y); + } + T2A = T2u + T2z; + Tde = T7v + T7w; + { + E T2G, T7o, T2L, T7p; + { + E T2D, T2F, T2C, T2E; + T2D = rio[WS(ios, 6)]; + T2F = iio[-WS(ios, 57)]; + T2C = W[10]; + T2E = W[11]; + T2G = FMA(T2C, T2D, T2E * T2F); + T7o = FNMS(T2E, T2D, T2C * T2F); + } + { + E T2I, T2K, T2H, T2J; + T2I = rio[WS(ios, 38)]; + T2K = iio[-WS(ios, 25)]; + T2H = W[74]; + T2J = W[75]; + T2L = FMA(T2H, T2I, T2J * T2K); + T7p = FNMS(T2J, T2I, T2H * T2K); + } + T2M = T2G + T2L; + Tdj = T7o + T7p; + T7n = T2G - T2L; + T7q = T7o - T7p; + } + { + E T2R, T7j, T2W, T7k; + { + E T2O, T2Q, T2N, T2P; + T2O = rio[WS(ios, 54)]; + T2Q = iio[-WS(ios, 9)]; + T2N = W[106]; + T2P = W[107]; + T2R = FMA(T2N, T2O, T2P * T2Q); + T7j = FNMS(T2P, T2O, T2N * T2Q); + } + { + E T2T, T2V, T2S, T2U; + T2T = rio[WS(ios, 22)]; + T2V = iio[-WS(ios, 41)]; + T2S = W[42]; + T2U = W[43]; + T2W = FMA(T2S, T2T, T2U * T2V); + T7k = FNMS(T2U, T2T, T2S * T2V); + } + T2X = T2R + T2W; + Tdk = T7j + T7k; + T7i = T2R - T2W; + T7l = T7j - T7k; + } + T2B = T2p + T2A; + T2Y = T2M + T2X; + Tfz = T2B - T2Y; + TfA = Tdd + Tde; + TfB = Tdj + Tdk; + TfC = TfA - TfB; + { + E T7f, T7g, Tdi, Tdl; + T7f = T7d - T7e; + T7g = T2u - T2z; + T7h = T7f + T7g; + TaW = T7f - T7g; + Tdi = T2p - T2A; + Tdl = Tdj - Tdk; + Tdm = Tdi - Tdl; + TeM = Tdi + Tdl; + } + { + E T7m, T7r, T7z, T7A; + T7m = T7i - T7l; + T7r = T7n + T7q; + T7s = KP707106781 * (T7m - T7r); + TaU = KP707106781 * (T7r + T7m); + T7z = T7q - T7n; + T7A = T7i + T7l; + T7B = KP707106781 * (T7z - T7A); + TaX = KP707106781 * (T7z + T7A); + } + { + E Tdf, Tdg, T7u, T7x; + Tdf = Tdd - Tde; + Tdg = T2X - T2M; + Tdh = Tdf - Tdg; + TeL = Tdf + Tdg; + T7u = T2j - T2o; + T7x = T7v - T7w; + T7y = T7u - T7x; + TaT = T7u + T7x; + } + } + { + E T36, T7G, T3b, T7H, T3c, Tdq, T3h, T8m, T3m, T8n, T3n, Tdr, T3z, TdI, T7Q; + E T7T, T3K, TdJ, T7L, T7O; + { + E T33, T35, T32, T34; + T33 = rio[WS(ios, 1)]; + T35 = iio[-WS(ios, 62)]; + T32 = W[0]; + T34 = W[1]; + T36 = FMA(T32, T33, T34 * T35); + T7G = FNMS(T34, T33, T32 * T35); + } + { + E T38, T3a, T37, T39; + T38 = rio[WS(ios, 33)]; + T3a = iio[-WS(ios, 30)]; + T37 = W[64]; + T39 = W[65]; + T3b = FMA(T37, T38, T39 * T3a); + T7H = FNMS(T39, T38, T37 * T3a); + } + T3c = T36 + T3b; + Tdq = T7G + T7H; + { + E T3e, T3g, T3d, T3f; + T3e = rio[WS(ios, 17)]; + T3g = iio[-WS(ios, 46)]; + T3d = W[32]; + T3f = W[33]; + T3h = FMA(T3d, T3e, T3f * T3g); + T8m = FNMS(T3f, T3e, T3d * T3g); + } + { + E T3j, T3l, T3i, T3k; + T3j = rio[WS(ios, 49)]; + T3l = iio[-WS(ios, 14)]; + T3i = W[96]; + T3k = W[97]; + T3m = FMA(T3i, T3j, T3k * T3l); + T8n = FNMS(T3k, T3j, T3i * T3l); + } + T3n = T3h + T3m; + Tdr = T8m + T8n; + { + E T3t, T7R, T3y, T7S; + { + E T3q, T3s, T3p, T3r; + T3q = rio[WS(ios, 9)]; + T3s = iio[-WS(ios, 54)]; + T3p = W[16]; + T3r = W[17]; + T3t = FMA(T3p, T3q, T3r * T3s); + T7R = FNMS(T3r, T3q, T3p * T3s); + } + { + E T3v, T3x, T3u, T3w; + T3v = rio[WS(ios, 41)]; + T3x = iio[-WS(ios, 22)]; + T3u = W[80]; + T3w = W[81]; + T3y = FMA(T3u, T3v, T3w * T3x); + T7S = FNMS(T3w, T3v, T3u * T3x); + } + T3z = T3t + T3y; + TdI = T7R + T7S; + T7Q = T3t - T3y; + T7T = T7R - T7S; + } + { + E T3E, T7M, T3J, T7N; + { + E T3B, T3D, T3A, T3C; + T3B = rio[WS(ios, 57)]; + T3D = iio[-WS(ios, 6)]; + T3A = W[112]; + T3C = W[113]; + T3E = FMA(T3A, T3B, T3C * T3D); + T7M = FNMS(T3C, T3B, T3A * T3D); + } + { + E T3G, T3I, T3F, T3H; + T3G = rio[WS(ios, 25)]; + T3I = iio[-WS(ios, 38)]; + T3F = W[48]; + T3H = W[49]; + T3J = FMA(T3F, T3G, T3H * T3I); + T7N = FNMS(T3H, T3G, T3F * T3I); + } + T3K = T3E + T3J; + TdJ = T7M + T7N; + T7L = T3E - T3J; + T7O = T7M - T7N; + } + { + E T3o, T3L, TdH, TdK; + T3o = T3c + T3n; + T3L = T3z + T3K; + T3M = T3o + T3L; + TfL = T3o - T3L; + TdH = T3c - T3n; + TdK = TdI - TdJ; + TdL = TdH - TdK; + TeQ = TdH + TdK; + } + { + E TfG, TfH, T7I, T7J; + TfG = Tdq + Tdr; + TfH = TdI + TdJ; + TfI = TfG - TfH; + Tgt = TfG + TfH; + T7I = T7G - T7H; + T7J = T3h - T3m; + T7K = T7I + T7J; + Tb2 = T7I - T7J; + } + { + E T7P, T7U, T8q, T8r; + T7P = T7L - T7O; + T7U = T7Q + T7T; + T7V = KP707106781 * (T7P - T7U); + Tbe = KP707106781 * (T7U + T7P); + T8q = T7T - T7Q; + T8r = T7L + T7O; + T8s = KP707106781 * (T8q - T8r); + Tb3 = KP707106781 * (T8q + T8r); + } + { + E Tds, Tdt, T8l, T8o; + Tds = Tdq - Tdr; + Tdt = T3K - T3z; + Tdu = Tds - Tdt; + TeT = Tds + Tdt; + T8l = T36 - T3b; + T8o = T8m - T8n; + T8p = T8l - T8o; + Tbd = T8l + T8o; + } + } + { + E T4D, T9e, T4I, T9f, T4J, Te8, T4O, T8A, T4T, T8B, T4U, Te9, T56, TdS, T8G; + E T8H, T5h, TdT, T8J, T8M; + { + E T4A, T4C, T4z, T4B; + T4A = rio[WS(ios, 63)]; + T4C = iio[0]; + T4z = W[124]; + T4B = W[125]; + T4D = FMA(T4z, T4A, T4B * T4C); + T9e = FNMS(T4B, T4A, T4z * T4C); + } + { + E T4F, T4H, T4E, T4G; + T4F = rio[WS(ios, 31)]; + T4H = iio[-WS(ios, 32)]; + T4E = W[60]; + T4G = W[61]; + T4I = FMA(T4E, T4F, T4G * T4H); + T9f = FNMS(T4G, T4F, T4E * T4H); + } + T4J = T4D + T4I; + Te8 = T9e + T9f; + { + E T4L, T4N, T4K, T4M; + T4L = rio[WS(ios, 15)]; + T4N = iio[-WS(ios, 48)]; + T4K = W[28]; + T4M = W[29]; + T4O = FMA(T4K, T4L, T4M * T4N); + T8A = FNMS(T4M, T4L, T4K * T4N); + } + { + E T4Q, T4S, T4P, T4R; + T4Q = rio[WS(ios, 47)]; + T4S = iio[-WS(ios, 16)]; + T4P = W[92]; + T4R = W[93]; + T4T = FMA(T4P, T4Q, T4R * T4S); + T8B = FNMS(T4R, T4Q, T4P * T4S); + } + T4U = T4O + T4T; + Te9 = T8A + T8B; + { + E T50, T8E, T55, T8F; + { + E T4X, T4Z, T4W, T4Y; + T4X = rio[WS(ios, 7)]; + T4Z = iio[-WS(ios, 56)]; + T4W = W[12]; + T4Y = W[13]; + T50 = FMA(T4W, T4X, T4Y * T4Z); + T8E = FNMS(T4Y, T4X, T4W * T4Z); + } + { + E T52, T54, T51, T53; + T52 = rio[WS(ios, 39)]; + T54 = iio[-WS(ios, 24)]; + T51 = W[76]; + T53 = W[77]; + T55 = FMA(T51, T52, T53 * T54); + T8F = FNMS(T53, T52, T51 * T54); + } + T56 = T50 + T55; + TdS = T8E + T8F; + T8G = T8E - T8F; + T8H = T50 - T55; + } + { + E T5b, T8K, T5g, T8L; + { + E T58, T5a, T57, T59; + T58 = rio[WS(ios, 55)]; + T5a = iio[-WS(ios, 8)]; + T57 = W[108]; + T59 = W[109]; + T5b = FMA(T57, T58, T59 * T5a); + T8K = FNMS(T59, T58, T57 * T5a); + } + { + E T5d, T5f, T5c, T5e; + T5d = rio[WS(ios, 23)]; + T5f = iio[-WS(ios, 40)]; + T5c = W[44]; + T5e = W[45]; + T5g = FMA(T5c, T5d, T5e * T5f); + T8L = FNMS(T5e, T5d, T5c * T5f); + } + T5h = T5b + T5g; + TdT = T8K + T8L; + T8J = T5b - T5g; + T8M = T8K - T8L; + } + { + E T4V, T5i, Tea, Teb; + T4V = T4J + T4U; + T5i = T56 + T5h; + T5j = T4V + T5i; + TfR = T4V - T5i; + Tea = Te8 - Te9; + Teb = T5h - T56; + Tec = Tea - Teb; + Tf0 = Tea + Teb; + } + { + E TfW, TfX, T8z, T8C; + TfW = Te8 + Te9; + TfX = TdS + TdT; + TfY = TfW - TfX; + Tgy = TfW + TfX; + T8z = T4D - T4I; + T8C = T8A - T8B; + T8D = T8z - T8C; + Tbl = T8z + T8C; + } + { + E T8I, T8N, T9j, T9k; + T8I = T8G - T8H; + T8N = T8J + T8M; + T8O = KP707106781 * (T8I - T8N); + Tbx = KP707106781 * (T8I + T8N); + T9j = T8J - T8M; + T9k = T8H + T8G; + T9l = KP707106781 * (T9j - T9k); + Tbm = KP707106781 * (T9k + T9j); + } + { + E TdR, TdU, T9g, T9h; + TdR = T4J - T4U; + TdU = TdS - TdT; + TdV = TdR - TdU; + TeX = TdR + TdU; + T9g = T9e - T9f; + T9h = T4O - T4T; + T9i = T9g + T9h; + Tbw = T9g - T9h; + } + } + { + E T5u, TdW, T8S, T8V, T62, Te3, T94, T99, T5F, TdX, T8T, T8Y, T5R, Te2, T93; + E T96; + { + E T5o, T8Q, T5t, T8R; + { + E T5l, T5n, T5k, T5m; + T5l = rio[WS(ios, 3)]; + T5n = iio[-WS(ios, 60)]; + T5k = W[4]; + T5m = W[5]; + T5o = FMA(T5k, T5l, T5m * T5n); + T8Q = FNMS(T5m, T5l, T5k * T5n); + } + { + E T5q, T5s, T5p, T5r; + T5q = rio[WS(ios, 35)]; + T5s = iio[-WS(ios, 28)]; + T5p = W[68]; + T5r = W[69]; + T5t = FMA(T5p, T5q, T5r * T5s); + T8R = FNMS(T5r, T5q, T5p * T5s); + } + T5u = T5o + T5t; + TdW = T8Q + T8R; + T8S = T8Q - T8R; + T8V = T5o - T5t; + } + { + E T5W, T97, T61, T98; + { + E T5T, T5V, T5S, T5U; + T5T = rio[WS(ios, 11)]; + T5V = iio[-WS(ios, 52)]; + T5S = W[20]; + T5U = W[21]; + T5W = FMA(T5S, T5T, T5U * T5V); + T97 = FNMS(T5U, T5T, T5S * T5V); + } + { + E T5Y, T60, T5X, T5Z; + T5Y = rio[WS(ios, 43)]; + T60 = iio[-WS(ios, 20)]; + T5X = W[84]; + T5Z = W[85]; + T61 = FMA(T5X, T5Y, T5Z * T60); + T98 = FNMS(T5Z, T5Y, T5X * T60); + } + T62 = T5W + T61; + Te3 = T97 + T98; + T94 = T5W - T61; + T99 = T97 - T98; + } + { + E T5z, T8W, T5E, T8X; + { + E T5w, T5y, T5v, T5x; + T5w = rio[WS(ios, 19)]; + T5y = iio[-WS(ios, 44)]; + T5v = W[36]; + T5x = W[37]; + T5z = FMA(T5v, T5w, T5x * T5y); + T8W = FNMS(T5x, T5w, T5v * T5y); + } + { + E T5B, T5D, T5A, T5C; + T5B = rio[WS(ios, 51)]; + T5D = iio[-WS(ios, 12)]; + T5A = W[100]; + T5C = W[101]; + T5E = FMA(T5A, T5B, T5C * T5D); + T8X = FNMS(T5C, T5B, T5A * T5D); + } + T5F = T5z + T5E; + TdX = T8W + T8X; + T8T = T5z - T5E; + T8Y = T8W - T8X; + } + { + E T5L, T91, T5Q, T92; + { + E T5I, T5K, T5H, T5J; + T5I = rio[WS(ios, 59)]; + T5K = iio[-WS(ios, 4)]; + T5H = W[116]; + T5J = W[117]; + T5L = FMA(T5H, T5I, T5J * T5K); + T91 = FNMS(T5J, T5I, T5H * T5K); + } + { + E T5N, T5P, T5M, T5O; + T5N = rio[WS(ios, 27)]; + T5P = iio[-WS(ios, 36)]; + T5M = W[52]; + T5O = W[53]; + T5Q = FMA(T5M, T5N, T5O * T5P); + T92 = FNMS(T5O, T5N, T5M * T5P); + } + T5R = T5L + T5Q; + Te2 = T91 + T92; + T93 = T91 - T92; + T96 = T5L - T5Q; + } + { + E T5G, T63, Te1, Te4; + T5G = T5u + T5F; + T63 = T5R + T62; + T64 = T5G + T63; + TfZ = T63 - T5G; + Te1 = T5R - T62; + Te4 = Te2 - Te3; + Te5 = Te1 + Te4; + Ted = Te1 - Te4; + } + { + E TfS, TfT, T8U, T8Z; + TfS = TdW + TdX; + TfT = Te2 + Te3; + TfU = TfS - TfT; + Tgz = TfS + TfT; + T8U = T8S + T8T; + T8Z = T8V - T8Y; + T90 = FNMS(KP923879532, T8Z, KP382683432 * T8U); + T9o = FMA(KP923879532, T8U, KP382683432 * T8Z); + } + { + E T95, T9a, Tbr, Tbs; + T95 = T93 + T94; + T9a = T96 - T99; + T9b = FMA(KP382683432, T95, KP923879532 * T9a); + T9n = FNMS(KP923879532, T95, KP382683432 * T9a); + Tbr = T93 - T94; + Tbs = T96 + T99; + Tbt = FMA(KP923879532, Tbr, KP382683432 * Tbs); + Tbz = FNMS(KP382683432, Tbr, KP923879532 * Tbs); + } + { + E TdY, TdZ, Tbo, Tbp; + TdY = TdW - TdX; + TdZ = T5u - T5F; + Te0 = TdY - TdZ; + Tee = TdZ + TdY; + Tbo = T8S - T8T; + Tbp = T8V + T8Y; + Tbq = FNMS(KP382683432, Tbp, KP923879532 * Tbo); + TbA = FMA(KP382683432, Tbo, KP923879532 * Tbp); + } + } + { + E T3X, TdB, T8a, T8d, T4v, Tdx, T80, T85, T48, TdC, T8b, T8g, T4k, Tdw, T7X; + E T84; + { + E T3R, T88, T3W, T89; + { + E T3O, T3Q, T3N, T3P; + T3O = rio[WS(ios, 5)]; + T3Q = iio[-WS(ios, 58)]; + T3N = W[8]; + T3P = W[9]; + T3R = FMA(T3N, T3O, T3P * T3Q); + T88 = FNMS(T3P, T3O, T3N * T3Q); + } + { + E T3T, T3V, T3S, T3U; + T3T = rio[WS(ios, 37)]; + T3V = iio[-WS(ios, 26)]; + T3S = W[72]; + T3U = W[73]; + T3W = FMA(T3S, T3T, T3U * T3V); + T89 = FNMS(T3U, T3T, T3S * T3V); + } + T3X = T3R + T3W; + TdB = T88 + T89; + T8a = T88 - T89; + T8d = T3R - T3W; + } + { + E T4p, T7Y, T4u, T7Z; + { + E T4m, T4o, T4l, T4n; + T4m = rio[WS(ios, 13)]; + T4o = iio[-WS(ios, 50)]; + T4l = W[24]; + T4n = W[25]; + T4p = FMA(T4l, T4m, T4n * T4o); + T7Y = FNMS(T4n, T4m, T4l * T4o); + } + { + E T4r, T4t, T4q, T4s; + T4r = rio[WS(ios, 45)]; + T4t = iio[-WS(ios, 18)]; + T4q = W[88]; + T4s = W[89]; + T4u = FMA(T4q, T4r, T4s * T4t); + T7Z = FNMS(T4s, T4r, T4q * T4t); + } + T4v = T4p + T4u; + Tdx = T7Y + T7Z; + T80 = T7Y - T7Z; + T85 = T4p - T4u; + } + { + E T42, T8e, T47, T8f; + { + E T3Z, T41, T3Y, T40; + T3Z = rio[WS(ios, 21)]; + T41 = iio[-WS(ios, 42)]; + T3Y = W[40]; + T40 = W[41]; + T42 = FMA(T3Y, T3Z, T40 * T41); + T8e = FNMS(T40, T3Z, T3Y * T41); + } + { + E T44, T46, T43, T45; + T44 = rio[WS(ios, 53)]; + T46 = iio[-WS(ios, 10)]; + T43 = W[104]; + T45 = W[105]; + T47 = FMA(T43, T44, T45 * T46); + T8f = FNMS(T45, T44, T43 * T46); + } + T48 = T42 + T47; + TdC = T8e + T8f; + T8b = T42 - T47; + T8g = T8e - T8f; + } + { + E T4e, T82, T4j, T83; + { + E T4b, T4d, T4a, T4c; + T4b = rio[WS(ios, 61)]; + T4d = iio[-WS(ios, 2)]; + T4a = W[120]; + T4c = W[121]; + T4e = FMA(T4a, T4b, T4c * T4d); + T82 = FNMS(T4c, T4b, T4a * T4d); + } + { + E T4g, T4i, T4f, T4h; + T4g = rio[WS(ios, 29)]; + T4i = iio[-WS(ios, 34)]; + T4f = W[56]; + T4h = W[57]; + T4j = FMA(T4f, T4g, T4h * T4i); + T83 = FNMS(T4h, T4g, T4f * T4i); + } + T4k = T4e + T4j; + Tdw = T82 + T83; + T7X = T4e - T4j; + T84 = T82 - T83; + } + { + E T49, T4w, TdA, TdD; + T49 = T3X + T48; + T4w = T4k + T4v; + T4x = T49 + T4w; + TfJ = T4w - T49; + TdA = T3X - T48; + TdD = TdB - TdC; + TdE = TdA + TdD; + TdM = TdD - TdA; + } + { + E TfM, TfN, T81, T86; + TfM = TdB + TdC; + TfN = Tdw + Tdx; + TfO = TfM - TfN; + Tgu = TfM + TfN; + T81 = T7X - T80; + T86 = T84 + T85; + T87 = FNMS(KP923879532, T86, KP382683432 * T81); + T8v = FMA(KP382683432, T86, KP923879532 * T81); + } + { + E T8c, T8h, Tb8, Tb9; + T8c = T8a + T8b; + T8h = T8d - T8g; + T8i = FMA(KP923879532, T8c, KP382683432 * T8h); + T8u = FNMS(KP923879532, T8h, KP382683432 * T8c); + Tb8 = T8a - T8b; + Tb9 = T8d + T8g; + Tba = FMA(KP382683432, Tb8, KP923879532 * Tb9); + Tbg = FNMS(KP382683432, Tb9, KP923879532 * Tb8); + } + { + E Tdv, Tdy, Tb5, Tb6; + Tdv = T4k - T4v; + Tdy = Tdw - Tdx; + Tdz = Tdv - Tdy; + TdN = Tdv + Tdy; + Tb5 = T7X + T80; + Tb6 = T84 - T85; + Tb7 = FNMS(KP382683432, Tb6, KP923879532 * Tb5); + Tbh = FMA(KP923879532, Tb6, KP382683432 * Tb5); + } + } + { + E T1t, Tgn, TgK, TgL, TgV, Th1, T30, Th0, T66, TgX, Tgw, TgE, TgB, TgF, Tgq; + E TgM; + { + E TH, T1s, TgI, TgJ; + TH = Tj + TG; + T1s = T14 + T1r; + T1t = TH + T1s; + Tgn = TH - T1s; + TgI = Tgt + Tgu; + TgJ = Tgy + Tgz; + TgK = TgI - TgJ; + TgL = TgI + TgJ; + } + { + E TgN, TgU, T2e, T2Z; + TgN = Tfq + Tfr; + TgU = TgO + TgT; + TgV = TgN + TgU; + Th1 = TgU - TgN; + T2e = T1Q + T2d; + T2Z = T2B + T2Y; + T30 = T2e + T2Z; + Th0 = T2Z - T2e; + } + { + E T4y, T65, Tgs, Tgv; + T4y = T3M + T4x; + T65 = T5j + T64; + T66 = T4y + T65; + TgX = T65 - T4y; + Tgs = T3M - T4x; + Tgv = Tgt - Tgu; + Tgw = Tgs + Tgv; + TgE = Tgv - Tgs; + } + { + E Tgx, TgA, Tgo, Tgp; + Tgx = T5j - T64; + TgA = Tgy - Tgz; + TgB = Tgx - TgA; + TgF = Tgx + TgA; + Tgo = Tfu + Tfv; + Tgp = TfA + TfB; + Tgq = Tgo - Tgp; + TgM = Tgo + Tgp; + } + { + E T31, TgW, TgH, TgY; + T31 = T1t + T30; + iio[-WS(ios, 32)] = T31 - T66; + rio[0] = T31 + T66; + TgW = TgM + TgV; + rio[WS(ios, 32)] = TgL - TgW; + iio[0] = TgL + TgW; + TgH = T1t - T30; + iio[-WS(ios, 48)] = TgH - TgK; + rio[WS(ios, 16)] = TgH + TgK; + TgY = TgV - TgM; + rio[WS(ios, 48)] = TgX - TgY; + iio[-WS(ios, 16)] = TgX + TgY; + } + { + E Tgr, TgC, TgZ, Th2; + Tgr = Tgn + Tgq; + TgC = KP707106781 * (Tgw + TgB); + iio[-WS(ios, 40)] = Tgr - TgC; + rio[WS(ios, 8)] = Tgr + TgC; + TgZ = KP707106781 * (TgE + TgF); + Th2 = Th0 + Th1; + rio[WS(ios, 40)] = TgZ - Th2; + iio[-WS(ios, 8)] = TgZ + Th2; + } + { + E TgD, TgG, Th3, Th4; + TgD = Tgn - Tgq; + TgG = KP707106781 * (TgE - TgF); + iio[-WS(ios, 56)] = TgD - TgG; + rio[WS(ios, 24)] = TgD + TgG; + Th3 = KP707106781 * (TgB - Tgw); + Th4 = Th1 - Th0; + rio[WS(ios, 56)] = Th3 - Th4; + iio[-WS(ios, 24)] = Th3 + Th4; + } + } + { + E Tft, Tg7, Tgh, Tgl, Th9, Thf, TfE, Th6, TfQ, Tg4, Tga, The, Tge, Tgk, Tg1; + E Tg5; + { + E Tfp, Tfs, Tgf, Tgg; + Tfp = Tj - TG; + Tfs = Tfq - Tfr; + Tft = Tfp - Tfs; + Tg7 = Tfp + Tfs; + Tgf = TfR + TfU; + Tgg = TfY + TfZ; + Tgh = FNMS(KP382683432, Tgg, KP923879532 * Tgf); + Tgl = FMA(KP923879532, Tgg, KP382683432 * Tgf); + } + { + E Th7, Th8, Tfy, TfD; + Th7 = T1r - T14; + Th8 = TgT - TgO; + Th9 = Th7 + Th8; + Thf = Th8 - Th7; + Tfy = Tfw - Tfx; + TfD = Tfz + TfC; + TfE = KP707106781 * (Tfy - TfD); + Th6 = KP707106781 * (Tfy + TfD); + } + { + E TfK, TfP, Tg8, Tg9; + TfK = TfI - TfJ; + TfP = TfL - TfO; + TfQ = FMA(KP923879532, TfK, KP382683432 * TfP); + Tg4 = FNMS(KP923879532, TfP, KP382683432 * TfK); + Tg8 = Tfx + Tfw; + Tg9 = Tfz - TfC; + Tga = KP707106781 * (Tg8 + Tg9); + The = KP707106781 * (Tg9 - Tg8); + } + { + E Tgc, Tgd, TfV, Tg0; + Tgc = TfI + TfJ; + Tgd = TfL + TfO; + Tge = FMA(KP382683432, Tgc, KP923879532 * Tgd); + Tgk = FNMS(KP382683432, Tgd, KP923879532 * Tgc); + TfV = TfR - TfU; + Tg0 = TfY - TfZ; + Tg1 = FNMS(KP923879532, Tg0, KP382683432 * TfV); + Tg5 = FMA(KP382683432, Tg0, KP923879532 * TfV); + } + { + E TfF, Tg2, Thd, Thg; + TfF = Tft + TfE; + Tg2 = TfQ + Tg1; + iio[-WS(ios, 44)] = TfF - Tg2; + rio[WS(ios, 12)] = TfF + Tg2; + Thd = Tg4 + Tg5; + Thg = The + Thf; + rio[WS(ios, 44)] = Thd - Thg; + iio[-WS(ios, 12)] = Thd + Thg; + } + { + E Tg3, Tg6, Thh, Thi; + Tg3 = Tft - TfE; + Tg6 = Tg4 - Tg5; + iio[-WS(ios, 60)] = Tg3 - Tg6; + rio[WS(ios, 28)] = Tg3 + Tg6; + Thh = Tg1 - TfQ; + Thi = Thf - The; + rio[WS(ios, 60)] = Thh - Thi; + iio[-WS(ios, 28)] = Thh + Thi; + } + { + E Tgb, Tgi, Th5, Tha; + Tgb = Tg7 + Tga; + Tgi = Tge + Tgh; + iio[-WS(ios, 36)] = Tgb - Tgi; + rio[WS(ios, 4)] = Tgb + Tgi; + Th5 = Tgk + Tgl; + Tha = Th6 + Th9; + rio[WS(ios, 36)] = Th5 - Tha; + iio[-WS(ios, 4)] = Th5 + Tha; + } + { + E Tgj, Tgm, Thb, Thc; + Tgj = Tg7 - Tga; + Tgm = Tgk - Tgl; + iio[-WS(ios, 52)] = Tgj - Tgm; + rio[WS(ios, 20)] = Tgj + Tgm; + Thb = Tgh - Tge; + Thc = Th9 - Th6; + rio[WS(ios, 52)] = Thb - Thc; + iio[-WS(ios, 20)] = Thb + Thc; + } + } + { + E Td1, Ten, Tdo, ThA, ThD, ThJ, Teq, ThI, Teh, TeB, Tel, Tex, TdQ, TeA, Tek; + E Teu; + { + E TcP, Td0, Teo, Tep; + TcP = TcL - TcO; + Td0 = KP707106781 * (TcU - TcZ); + Td1 = TcP - Td0; + Ten = TcP + Td0; + { + E Tdc, Tdn, ThB, ThC; + Tdc = FNMS(KP923879532, Tdb, KP382683432 * Td6); + Tdn = FMA(KP382683432, Tdh, KP923879532 * Tdm); + Tdo = Tdc - Tdn; + ThA = Tdc + Tdn; + ThB = KP707106781 * (TeF - TeE); + ThC = Thn - Thm; + ThD = ThB + ThC; + ThJ = ThC - ThB; + } + Teo = FMA(KP923879532, Td6, KP382683432 * Tdb); + Tep = FNMS(KP923879532, Tdh, KP382683432 * Tdm); + Teq = Teo + Tep; + ThI = Tep - Teo; + { + E Te7, Tev, Teg, Tew, Te6, Tef; + Te6 = KP707106781 * (Te0 - Te5); + Te7 = TdV - Te6; + Tev = TdV + Te6; + Tef = KP707106781 * (Ted - Tee); + Teg = Tec - Tef; + Tew = Tec + Tef; + Teh = FNMS(KP980785280, Teg, KP195090322 * Te7); + TeB = FMA(KP831469612, Tew, KP555570233 * Tev); + Tel = FMA(KP195090322, Teg, KP980785280 * Te7); + Tex = FNMS(KP555570233, Tew, KP831469612 * Tev); + } + { + E TdG, Tes, TdP, Tet, TdF, TdO; + TdF = KP707106781 * (Tdz - TdE); + TdG = Tdu - TdF; + Tes = Tdu + TdF; + TdO = KP707106781 * (TdM - TdN); + TdP = TdL - TdO; + Tet = TdL + TdO; + TdQ = FMA(KP980785280, TdG, KP195090322 * TdP); + TeA = FNMS(KP555570233, Tet, KP831469612 * Tes); + Tek = FNMS(KP980785280, TdP, KP195090322 * TdG); + Teu = FMA(KP555570233, Tes, KP831469612 * Tet); + } + } + { + E Tdp, Tei, ThH, ThK; + Tdp = Td1 + Tdo; + Tei = TdQ + Teh; + iio[-WS(ios, 46)] = Tdp - Tei; + rio[WS(ios, 14)] = Tdp + Tei; + ThH = Tek + Tel; + ThK = ThI + ThJ; + rio[WS(ios, 46)] = ThH - ThK; + iio[-WS(ios, 14)] = ThH + ThK; + } + { + E Tej, Tem, ThL, ThM; + Tej = Td1 - Tdo; + Tem = Tek - Tel; + iio[-WS(ios, 62)] = Tej - Tem; + rio[WS(ios, 30)] = Tej + Tem; + ThL = Teh - TdQ; + ThM = ThJ - ThI; + rio[WS(ios, 62)] = ThL - ThM; + iio[-WS(ios, 30)] = ThL + ThM; + } + { + E Ter, Tey, Thz, ThE; + Ter = Ten + Teq; + Tey = Teu + Tex; + iio[-WS(ios, 38)] = Ter - Tey; + rio[WS(ios, 6)] = Ter + Tey; + Thz = TeA + TeB; + ThE = ThA + ThD; + rio[WS(ios, 38)] = Thz - ThE; + iio[-WS(ios, 6)] = Thz + ThE; + } + { + E Tez, TeC, ThF, ThG; + Tez = Ten - Teq; + TeC = TeA - TeB; + iio[-WS(ios, 54)] = Tez - TeC; + rio[WS(ios, 22)] = Tez + TeC; + ThF = Tex - Teu; + ThG = ThD - ThA; + rio[WS(ios, 54)] = ThF - ThG; + iio[-WS(ios, 22)] = ThF + ThG; + } + } + { + E TeH, Tf9, TeO, Thk, Thp, Thv, Tfc, Thu, Tf3, Tfn, Tf7, Tfj, TeW, Tfm, Tf6; + E Tfg; + { + E TeD, TeG, Tfa, Tfb; + TeD = TcL + TcO; + TeG = KP707106781 * (TeE + TeF); + TeH = TeD - TeG; + Tf9 = TeD + TeG; + { + E TeK, TeN, Thl, Tho; + TeK = FNMS(KP382683432, TeJ, KP923879532 * TeI); + TeN = FMA(KP923879532, TeL, KP382683432 * TeM); + TeO = TeK - TeN; + Thk = TeK + TeN; + Thl = KP707106781 * (TcU + TcZ); + Tho = Thm + Thn; + Thp = Thl + Tho; + Thv = Tho - Thl; + } + Tfa = FMA(KP382683432, TeI, KP923879532 * TeJ); + Tfb = FNMS(KP382683432, TeL, KP923879532 * TeM); + Tfc = Tfa + Tfb; + Thu = Tfb - Tfa; + { + E TeZ, Tfh, Tf2, Tfi, TeY, Tf1; + TeY = KP707106781 * (Tee + Ted); + TeZ = TeX - TeY; + Tfh = TeX + TeY; + Tf1 = KP707106781 * (Te0 + Te5); + Tf2 = Tf0 - Tf1; + Tfi = Tf0 + Tf1; + Tf3 = FNMS(KP831469612, Tf2, KP555570233 * TeZ); + Tfn = FMA(KP195090322, Tfh, KP980785280 * Tfi); + Tf7 = FMA(KP831469612, TeZ, KP555570233 * Tf2); + Tfj = FNMS(KP195090322, Tfi, KP980785280 * Tfh); + } + { + E TeS, Tfe, TeV, Tff, TeR, TeU; + TeR = KP707106781 * (TdE + Tdz); + TeS = TeQ - TeR; + Tfe = TeQ + TeR; + TeU = KP707106781 * (TdM + TdN); + TeV = TeT - TeU; + Tff = TeT + TeU; + TeW = FMA(KP555570233, TeS, KP831469612 * TeV); + Tfm = FNMS(KP195090322, Tfe, KP980785280 * Tff); + Tf6 = FNMS(KP831469612, TeS, KP555570233 * TeV); + Tfg = FMA(KP980785280, Tfe, KP195090322 * Tff); + } + } + { + E TeP, Tf4, Tht, Thw; + TeP = TeH + TeO; + Tf4 = TeW + Tf3; + iio[-WS(ios, 42)] = TeP - Tf4; + rio[WS(ios, 10)] = TeP + Tf4; + Tht = Tf6 + Tf7; + Thw = Thu + Thv; + rio[WS(ios, 42)] = Tht - Thw; + iio[-WS(ios, 10)] = Tht + Thw; + } + { + E Tf5, Tf8, Thx, Thy; + Tf5 = TeH - TeO; + Tf8 = Tf6 - Tf7; + iio[-WS(ios, 58)] = Tf5 - Tf8; + rio[WS(ios, 26)] = Tf5 + Tf8; + Thx = Tf3 - TeW; + Thy = Thv - Thu; + rio[WS(ios, 58)] = Thx - Thy; + iio[-WS(ios, 26)] = Thx + Thy; + } + { + E Tfd, Tfk, Thj, Thq; + Tfd = Tf9 + Tfc; + Tfk = Tfg + Tfj; + iio[-WS(ios, 34)] = Tfd - Tfk; + rio[WS(ios, 2)] = Tfd + Tfk; + Thj = Tfm + Tfn; + Thq = Thk + Thp; + rio[WS(ios, 34)] = Thj - Thq; + iio[-WS(ios, 2)] = Thj + Thq; + } + { + E Tfl, Tfo, Thr, Ths; + Tfl = Tf9 - Tfc; + Tfo = Tfm - Tfn; + iio[-WS(ios, 50)] = Tfl - Tfo; + rio[WS(ios, 18)] = Tfl + Tfo; + Thr = Tfj - Tfg; + Ths = Thp - Thk; + rio[WS(ios, 50)] = Thr - Ths; + iio[-WS(ios, 18)] = Thr + Ths; + } + } + { + E T6L, T9x, TiD, TiJ, T7E, TiI, T9A, TiA, T8y, T9K, T9u, T9E, T9r, T9L, T9v; + E T9H; + { + E T6n, T6K, TiB, TiC; + T6n = T6b - T6m; + T6K = T6y - T6J; + T6L = T6n - T6K; + T9x = T6n + T6K; + TiB = T9P - T9O; + TiC = Tin - Tim; + TiD = TiB + TiC; + TiJ = TiC - TiB; + } + { + E T7c, T9y, T7D, T9z; + { + E T72, T7b, T7t, T7C; + T72 = T6Q - T71; + T7b = T77 - T7a; + T7c = FNMS(KP980785280, T7b, KP195090322 * T72); + T9y = FMA(KP980785280, T72, KP195090322 * T7b); + T7t = T7h - T7s; + T7C = T7y - T7B; + T7D = FMA(KP195090322, T7t, KP980785280 * T7C); + T9z = FNMS(KP980785280, T7t, KP195090322 * T7C); + } + T7E = T7c - T7D; + TiI = T9z - T9y; + T9A = T9y + T9z; + TiA = T7c + T7D; + } + { + E T8k, T9C, T8x, T9D; + { + E T7W, T8j, T8t, T8w; + T7W = T7K - T7V; + T8j = T87 - T8i; + T8k = T7W - T8j; + T9C = T7W + T8j; + T8t = T8p - T8s; + T8w = T8u - T8v; + T8x = T8t - T8w; + T9D = T8t + T8w; + } + T8y = FMA(KP995184726, T8k, KP098017140 * T8x); + T9K = FNMS(KP634393284, T9D, KP773010453 * T9C); + T9u = FNMS(KP995184726, T8x, KP098017140 * T8k); + T9E = FMA(KP634393284, T9C, KP773010453 * T9D); + } + { + E T9d, T9F, T9q, T9G; + { + E T8P, T9c, T9m, T9p; + T8P = T8D - T8O; + T9c = T90 - T9b; + T9d = T8P - T9c; + T9F = T8P + T9c; + T9m = T9i - T9l; + T9p = T9n - T9o; + T9q = T9m - T9p; + T9G = T9m + T9p; + } + T9r = FNMS(KP995184726, T9q, KP098017140 * T9d); + T9L = FMA(KP773010453, T9G, KP634393284 * T9F); + T9v = FMA(KP098017140, T9q, KP995184726 * T9d); + T9H = FNMS(KP634393284, T9G, KP773010453 * T9F); + } + { + E T7F, T9s, TiH, TiK; + T7F = T6L + T7E; + T9s = T8y + T9r; + iio[-WS(ios, 47)] = T7F - T9s; + rio[WS(ios, 15)] = T7F + T9s; + TiH = T9u + T9v; + TiK = TiI + TiJ; + rio[WS(ios, 47)] = TiH - TiK; + iio[-WS(ios, 15)] = TiH + TiK; + } + { + E T9t, T9w, TiL, TiM; + T9t = T6L - T7E; + T9w = T9u - T9v; + iio[-WS(ios, 63)] = T9t - T9w; + rio[WS(ios, 31)] = T9t + T9w; + TiL = T9r - T8y; + TiM = TiJ - TiI; + rio[WS(ios, 63)] = TiL - TiM; + iio[-WS(ios, 31)] = TiL + TiM; + } + { + E T9B, T9I, Tiz, TiE; + T9B = T9x + T9A; + T9I = T9E + T9H; + iio[-WS(ios, 39)] = T9B - T9I; + rio[WS(ios, 7)] = T9B + T9I; + Tiz = T9K + T9L; + TiE = TiA + TiD; + rio[WS(ios, 39)] = Tiz - TiE; + iio[-WS(ios, 7)] = Tiz + TiE; + } + { + E T9J, T9M, TiF, TiG; + T9J = T9x - T9A; + T9M = T9K - T9L; + iio[-WS(ios, 55)] = T9J - T9M; + rio[WS(ios, 23)] = T9J + T9M; + TiF = T9H - T9E; + TiG = TiD - TiA; + rio[WS(ios, 55)] = TiF - TiG; + iio[-WS(ios, 23)] = TiF + TiG; + } + } + { + E TaL, TbJ, Ti9, Tif, Tb0, Tie, TbM, Ti6, Tbk, TbW, TbG, TbQ, TbD, TbX, TbH; + E TbT; + { + E TaD, TaK, Ti7, Ti8; + TaD = Taz - TaC; + TaK = TaG - TaJ; + TaL = TaD - TaK; + TbJ = TaD + TaK; + Ti7 = Tc1 - Tc0; + Ti8 = ThT - ThQ; + Ti9 = Ti7 + Ti8; + Tif = Ti8 - Ti7; + } + { + E TaS, TbK, TaZ, TbL; + { + E TaO, TaR, TaV, TaY; + TaO = TaM - TaN; + TaR = TaP - TaQ; + TaS = FNMS(KP831469612, TaR, KP555570233 * TaO); + TbK = FMA(KP555570233, TaR, KP831469612 * TaO); + TaV = TaT - TaU; + TaY = TaW - TaX; + TaZ = FMA(KP831469612, TaV, KP555570233 * TaY); + TbL = FNMS(KP831469612, TaY, KP555570233 * TaV); + } + Tb0 = TaS - TaZ; + Tie = TbL - TbK; + TbM = TbK + TbL; + Ti6 = TaS + TaZ; + } + { + E Tbc, TbO, Tbj, TbP; + { + E Tb4, Tbb, Tbf, Tbi; + Tb4 = Tb2 - Tb3; + Tbb = Tb7 - Tba; + Tbc = Tb4 - Tbb; + TbO = Tb4 + Tbb; + Tbf = Tbd - Tbe; + Tbi = Tbg - Tbh; + Tbj = Tbf - Tbi; + TbP = Tbf + Tbi; + } + Tbk = FMA(KP956940335, Tbc, KP290284677 * Tbj); + TbW = FNMS(KP471396736, TbP, KP881921264 * TbO); + TbG = FNMS(KP956940335, Tbj, KP290284677 * Tbc); + TbQ = FMA(KP471396736, TbO, KP881921264 * TbP); + } + { + E Tbv, TbR, TbC, TbS; + { + E Tbn, Tbu, Tby, TbB; + Tbn = Tbl - Tbm; + Tbu = Tbq - Tbt; + Tbv = Tbn - Tbu; + TbR = Tbn + Tbu; + Tby = Tbw - Tbx; + TbB = Tbz - TbA; + TbC = Tby - TbB; + TbS = Tby + TbB; + } + TbD = FNMS(KP956940335, TbC, KP290284677 * Tbv); + TbX = FMA(KP881921264, TbS, KP471396736 * TbR); + TbH = FMA(KP290284677, TbC, KP956940335 * Tbv); + TbT = FNMS(KP471396736, TbS, KP881921264 * TbR); + } + { + E Tb1, TbE, Tid, Tig; + Tb1 = TaL + Tb0; + TbE = Tbk + TbD; + iio[-WS(ios, 45)] = Tb1 - TbE; + rio[WS(ios, 13)] = Tb1 + TbE; + Tid = TbG + TbH; + Tig = Tie + Tif; + rio[WS(ios, 45)] = Tid - Tig; + iio[-WS(ios, 13)] = Tid + Tig; + } + { + E TbF, TbI, Tih, Tii; + TbF = TaL - Tb0; + TbI = TbG - TbH; + iio[-WS(ios, 61)] = TbF - TbI; + rio[WS(ios, 29)] = TbF + TbI; + Tih = TbD - Tbk; + Tii = Tif - Tie; + rio[WS(ios, 61)] = Tih - Tii; + iio[-WS(ios, 29)] = Tih + Tii; + } + { + E TbN, TbU, Ti5, Tia; + TbN = TbJ + TbM; + TbU = TbQ + TbT; + iio[-WS(ios, 37)] = TbN - TbU; + rio[WS(ios, 5)] = TbN + TbU; + Ti5 = TbW + TbX; + Tia = Ti6 + Ti9; + rio[WS(ios, 37)] = Ti5 - Tia; + iio[-WS(ios, 5)] = Ti5 + Tia; + } + { + E TbV, TbY, Tib, Tic; + TbV = TbJ - TbM; + TbY = TbW - TbX; + iio[-WS(ios, 53)] = TbV - TbY; + rio[WS(ios, 21)] = TbV + TbY; + Tib = TbT - TbQ; + Tic = Ti9 - Ti6; + rio[WS(ios, 53)] = Tib - Tic; + iio[-WS(ios, 21)] = Tib + Tic; + } + } + { + E Tc3, Tcv, ThV, Ti1, Tca, Ti0, Tcy, ThO, Tci, TcI, Tcs, TcC, Tcp, TcJ, Tct; + E TcF; + { + E TbZ, Tc2, ThP, ThU; + TbZ = Taz + TaC; + Tc2 = Tc0 + Tc1; + Tc3 = TbZ - Tc2; + Tcv = TbZ + Tc2; + ThP = TaG + TaJ; + ThU = ThQ + ThT; + ThV = ThP + ThU; + Ti1 = ThU - ThP; + } + { + E Tc6, Tcw, Tc9, Tcx; + { + E Tc4, Tc5, Tc7, Tc8; + Tc4 = TaM + TaN; + Tc5 = TaP + TaQ; + Tc6 = FNMS(KP195090322, Tc5, KP980785280 * Tc4); + Tcw = FMA(KP980785280, Tc5, KP195090322 * Tc4); + Tc7 = TaT + TaU; + Tc8 = TaW + TaX; + Tc9 = FMA(KP195090322, Tc7, KP980785280 * Tc8); + Tcx = FNMS(KP195090322, Tc8, KP980785280 * Tc7); + } + Tca = Tc6 - Tc9; + Ti0 = Tcx - Tcw; + Tcy = Tcw + Tcx; + ThO = Tc6 + Tc9; + } + { + E Tce, TcA, Tch, TcB; + { + E Tcc, Tcd, Tcf, Tcg; + Tcc = Tbd + Tbe; + Tcd = Tba + Tb7; + Tce = Tcc - Tcd; + TcA = Tcc + Tcd; + Tcf = Tb2 + Tb3; + Tcg = Tbg + Tbh; + Tch = Tcf - Tcg; + TcB = Tcf + Tcg; + } + Tci = FMA(KP634393284, Tce, KP773010453 * Tch); + TcI = FNMS(KP098017140, TcA, KP995184726 * TcB); + Tcs = FNMS(KP773010453, Tce, KP634393284 * Tch); + TcC = FMA(KP995184726, TcA, KP098017140 * TcB); + } + { + E Tcl, TcD, Tco, TcE; + { + E Tcj, Tck, Tcm, Tcn; + Tcj = Tbl + Tbm; + Tck = TbA + Tbz; + Tcl = Tcj - Tck; + TcD = Tcj + Tck; + Tcm = Tbw + Tbx; + Tcn = Tbq + Tbt; + Tco = Tcm - Tcn; + TcE = Tcm + Tcn; + } + Tcp = FNMS(KP773010453, Tco, KP634393284 * Tcl); + TcJ = FMA(KP098017140, TcD, KP995184726 * TcE); + Tct = FMA(KP773010453, Tcl, KP634393284 * Tco); + TcF = FNMS(KP098017140, TcE, KP995184726 * TcD); + } + { + E Tcb, Tcq, ThZ, Ti2; + Tcb = Tc3 + Tca; + Tcq = Tci + Tcp; + iio[-WS(ios, 41)] = Tcb - Tcq; + rio[WS(ios, 9)] = Tcb + Tcq; + ThZ = Tcs + Tct; + Ti2 = Ti0 + Ti1; + rio[WS(ios, 41)] = ThZ - Ti2; + iio[-WS(ios, 9)] = ThZ + Ti2; + } + { + E Tcr, Tcu, Ti3, Ti4; + Tcr = Tc3 - Tca; + Tcu = Tcs - Tct; + iio[-WS(ios, 57)] = Tcr - Tcu; + rio[WS(ios, 25)] = Tcr + Tcu; + Ti3 = Tcp - Tci; + Ti4 = Ti1 - Ti0; + rio[WS(ios, 57)] = Ti3 - Ti4; + iio[-WS(ios, 25)] = Ti3 + Ti4; + } + { + E Tcz, TcG, ThN, ThW; + Tcz = Tcv + Tcy; + TcG = TcC + TcF; + iio[-WS(ios, 33)] = Tcz - TcG; + rio[WS(ios, 1)] = Tcz + TcG; + ThN = TcI + TcJ; + ThW = ThO + ThV; + rio[WS(ios, 33)] = ThN - ThW; + iio[-WS(ios, 1)] = ThN + ThW; + } + { + E TcH, TcK, ThX, ThY; + TcH = Tcv - Tcy; + TcK = TcI - TcJ; + iio[-WS(ios, 49)] = TcH - TcK; + rio[WS(ios, 17)] = TcH + TcK; + ThX = TcF - TcC; + ThY = ThV - ThO; + rio[WS(ios, 49)] = ThX - ThY; + iio[-WS(ios, 17)] = ThX + ThY; + } + } + { + E T9R, Taj, Tip, Tiv, T9Y, Tiu, Tam, Tik, Ta6, Taw, Tag, Taq, Tad, Tax, Tah; + E Tat; + { + E T9N, T9Q, Til, Tio; + T9N = T6b + T6m; + T9Q = T9O + T9P; + T9R = T9N - T9Q; + Taj = T9N + T9Q; + Til = T6y + T6J; + Tio = Tim + Tin; + Tip = Til + Tio; + Tiv = Tio - Til; + } + { + E T9U, Tak, T9X, Tal; + { + E T9S, T9T, T9V, T9W; + T9S = T6Q + T71; + T9T = T77 + T7a; + T9U = FNMS(KP555570233, T9T, KP831469612 * T9S); + Tak = FMA(KP555570233, T9S, KP831469612 * T9T); + T9V = T7h + T7s; + T9W = T7y + T7B; + T9X = FMA(KP831469612, T9V, KP555570233 * T9W); + Tal = FNMS(KP555570233, T9V, KP831469612 * T9W); + } + T9Y = T9U - T9X; + Tiu = Tal - Tak; + Tam = Tak + Tal; + Tik = T9U + T9X; + } + { + E Ta2, Tao, Ta5, Tap; + { + E Ta0, Ta1, Ta3, Ta4; + Ta0 = T8p + T8s; + Ta1 = T8i + T87; + Ta2 = Ta0 - Ta1; + Tao = Ta0 + Ta1; + Ta3 = T7K + T7V; + Ta4 = T8u + T8v; + Ta5 = Ta3 - Ta4; + Tap = Ta3 + Ta4; + } + Ta6 = FMA(KP471396736, Ta2, KP881921264 * Ta5); + Taw = FNMS(KP290284677, Tao, KP956940335 * Tap); + Tag = FNMS(KP881921264, Ta2, KP471396736 * Ta5); + Taq = FMA(KP956940335, Tao, KP290284677 * Tap); + } + { + E Ta9, Tar, Tac, Tas; + { + E Ta7, Ta8, Taa, Tab; + Ta7 = T8D + T8O; + Ta8 = T9o + T9n; + Ta9 = Ta7 - Ta8; + Tar = Ta7 + Ta8; + Taa = T9i + T9l; + Tab = T90 + T9b; + Tac = Taa - Tab; + Tas = Taa + Tab; + } + Tad = FNMS(KP881921264, Tac, KP471396736 * Ta9); + Tax = FMA(KP290284677, Tar, KP956940335 * Tas); + Tah = FMA(KP881921264, Ta9, KP471396736 * Tac); + Tat = FNMS(KP290284677, Tas, KP956940335 * Tar); + } + { + E T9Z, Tae, Tit, Tiw; + T9Z = T9R + T9Y; + Tae = Ta6 + Tad; + iio[-WS(ios, 43)] = T9Z - Tae; + rio[WS(ios, 11)] = T9Z + Tae; + Tit = Tag + Tah; + Tiw = Tiu + Tiv; + rio[WS(ios, 43)] = Tit - Tiw; + iio[-WS(ios, 11)] = Tit + Tiw; + } + { + E Taf, Tai, Tix, Tiy; + Taf = T9R - T9Y; + Tai = Tag - Tah; + iio[-WS(ios, 59)] = Taf - Tai; + rio[WS(ios, 27)] = Taf + Tai; + Tix = Tad - Ta6; + Tiy = Tiv - Tiu; + rio[WS(ios, 59)] = Tix - Tiy; + iio[-WS(ios, 27)] = Tix + Tiy; + } + { + E Tan, Tau, Tij, Tiq; + Tan = Taj + Tam; + Tau = Taq + Tat; + iio[-WS(ios, 35)] = Tan - Tau; + rio[WS(ios, 3)] = Tan + Tau; + Tij = Taw + Tax; + Tiq = Tik + Tip; + rio[WS(ios, 35)] = Tij - Tiq; + iio[-WS(ios, 3)] = Tij + Tiq; + } + { + E Tav, Tay, Tir, Tis; + Tav = Taj - Tam; + Tay = Taw - Tax; + iio[-WS(ios, 51)] = Tav - Tay; + rio[WS(ios, 19)] = Tav + Tay; + Tir = Tat - Taq; + Tis = Tip - Tik; + rio[WS(ios, 51)] = Tir - Tis; + iio[-WS(ios, 19)] = Tir + Tis; + } + } + } + return W; +} + +static const tw_instr twinstr[] = { + {TW_FULL, 0, 64}, + {TW_NEXT, 1, 0} +}; + +static const hc2hc_desc desc = { 64, "hf_64", twinstr, {808, 270, 230, 0}, &GENUS, 0, 0, 0 }; + +void X(codelet_hf_64) (planner *p) { + X(khc2hc_dit_register) (p, hf_64, &desc); +} diff --git a/src/fftw3/rdft/codelets/r2hc/hf_7.c b/src/fftw3/rdft/codelets/r2hc/hf_7.c new file mode 100644 index 0000000..df7b4ac --- /dev/null +++ b/src/fftw3/rdft/codelets/r2hc/hf_7.c @@ -0,0 +1,178 @@ +/* + * 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 21:56:56 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_hc2hc -compact -variables 4 -n 7 -dit -name hf_7 -include hf.h */ + +/* + * This function contains 72 FP additions, 60 FP multiplications, + * (or, 36 additions, 24 multiplications, 36 fused multiply/add), + * 29 stack variables, and 28 memory accesses + */ +/* + * Generator Id's : + * $Id: hf_7.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: hf_7.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: hf_7.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + */ + +#include "hf.h" + +static const R *hf_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(KP433883739, +0.433883739117558120475768332848358754609990728); + DK(KP781831482, +0.781831482468029808708444526674057750232334519); + DK(KP974927912, +0.974927912181823607018131682993931217232785801); + int i; + for (i = m - 2; i > 0; i = i - 2, rio = rio + dist, iio = iio - dist, W = W + 12) { + E T1, Tc, TS, TC, TO, TR, Tn, TT, TI, TP, Ty, TU, TF, TQ; + T1 = rio[0]; + { + E T6, TA, Tb, TB; + { + E T3, T5, T2, T4; + T3 = rio[WS(ios, 1)]; + T5 = iio[-WS(ios, 5)]; + T2 = W[0]; + T4 = W[1]; + T6 = FMA(T2, T3, T4 * T5); + TA = FNMS(T4, T3, T2 * T5); + } + { + E T8, Ta, T7, T9; + T8 = rio[WS(ios, 6)]; + Ta = iio[0]; + T7 = W[10]; + T9 = W[11]; + Tb = FMA(T7, T8, T9 * Ta); + TB = FNMS(T9, T8, T7 * Ta); + } + Tc = T6 + Tb; + TS = Tb - T6; + TC = TA - TB; + TO = TA + TB; + } + TR = iio[-WS(ios, 6)]; + { + E Th, TG, Tm, TH; + { + E Te, Tg, Td, Tf; + Te = rio[WS(ios, 2)]; + Tg = iio[-WS(ios, 4)]; + Td = W[2]; + Tf = W[3]; + Th = FMA(Td, Te, Tf * Tg); + TG = FNMS(Tf, Te, Td * Tg); + } + { + E Tj, Tl, Ti, Tk; + Tj = rio[WS(ios, 5)]; + Tl = iio[-WS(ios, 1)]; + Ti = W[8]; + Tk = W[9]; + Tm = FMA(Ti, Tj, Tk * Tl); + TH = FNMS(Tk, Tj, Ti * Tl); + } + Tn = Th + Tm; + TT = Tm - Th; + TI = TG - TH; + TP = TG + TH; + } + { + E Ts, TD, Tx, TE; + { + E Tp, Tr, To, Tq; + Tp = rio[WS(ios, 3)]; + Tr = iio[-WS(ios, 3)]; + To = W[4]; + Tq = W[5]; + Ts = FMA(To, Tp, Tq * Tr); + TD = FNMS(Tq, Tp, To * Tr); + } + { + E Tu, Tw, Tt, Tv; + Tu = rio[WS(ios, 4)]; + Tw = iio[-WS(ios, 2)]; + Tt = W[6]; + Tv = W[7]; + Tx = FMA(Tt, Tu, Tv * Tw); + TE = FNMS(Tv, Tu, Tt * Tw); + } + Ty = Ts + Tx; + TU = Tx - Ts; + TF = TD - TE; + TQ = TD + TE; + } + rio[0] = T1 + Tc + Tn + Ty; + iio[0] = TO + TP + TQ + TR; + { + E TJ, Tz, TX, TY; + TJ = FNMS(KP781831482, TF, KP974927912 * TC) - (KP433883739 * TI); + Tz = FMA(KP623489801, Ty, T1) + FNMA(KP900968867, Tn, KP222520933 * Tc); + iio[-WS(ios, 5)] = Tz - TJ; + rio[WS(ios, 2)] = Tz + TJ; + TX = FNMS(KP781831482, TU, KP974927912 * TS) - (KP433883739 * TT); + TY = FMA(KP623489801, TQ, TR) + FNMA(KP900968867, TP, KP222520933 * TO); + rio[WS(ios, 5)] = TX - TY; + iio[-WS(ios, 2)] = TX + TY; + } + { + E TL, TK, TV, TW; + TL = FMA(KP781831482, TC, KP974927912 * TI) + (KP433883739 * TF); + TK = FMA(KP623489801, Tc, T1) + FNMA(KP900968867, Ty, KP222520933 * Tn); + iio[-WS(ios, 6)] = TK - TL; + rio[WS(ios, 1)] = TK + TL; + TV = FMA(KP781831482, TS, KP974927912 * TT) + (KP433883739 * TU); + TW = FMA(KP623489801, TO, TR) + FNMA(KP900968867, TQ, KP222520933 * TP); + rio[WS(ios, 6)] = TV - TW; + iio[-WS(ios, 1)] = TV + TW; + } + { + E TN, TM, TZ, T10; + TN = FMA(KP433883739, TC, KP974927912 * TF) - (KP781831482 * TI); + TM = FMA(KP623489801, Tn, T1) + FNMA(KP222520933, Ty, KP900968867 * Tc); + iio[-WS(ios, 4)] = TM - TN; + rio[WS(ios, 3)] = TM + TN; + TZ = FMA(KP433883739, TS, KP974927912 * TU) - (KP781831482 * TT); + T10 = FMA(KP623489801, TP, TR) + FNMA(KP222520933, TQ, KP900968867 * TO); + rio[WS(ios, 4)] = TZ - T10; + iio[-WS(ios, 3)] = TZ + T10; + } + } + return W; +} + +static const tw_instr twinstr[] = { + {TW_FULL, 0, 7}, + {TW_NEXT, 1, 0} +}; + +static const hc2hc_desc desc = { 7, "hf_7", twinstr, {36, 24, 36, 0}, &GENUS, 0, 0, 0 }; + +void X(codelet_hf_7) (planner *p) { + X(khc2hc_dit_register) (p, hf_7, &desc); +} diff --git a/src/fftw3/rdft/codelets/r2hc/hf_8.c b/src/fftw3/rdft/codelets/r2hc/hf_8.c new file mode 100644 index 0000000..21dedce --- /dev/null +++ b/src/fftw3/rdft/codelets/r2hc/hf_8.c @@ -0,0 +1,203 @@ +/* + * 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 21:56:58 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_hc2hc -compact -variables 4 -n 8 -dit -name hf_8 -include hf.h */ + +/* + * This function contains 66 FP additions, 32 FP multiplications, + * (or, 52 additions, 18 multiplications, 14 fused multiply/add), + * 28 stack variables, and 32 memory accesses + */ +/* + * Generator Id's : + * $Id: hf_8.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: hf_8.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: hf_8.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + */ + +#include "hf.h" + +static const R *hf_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, T1e, TH, T19, TF, T13, TR, TU, Ti, T1f, TK, T16, Tu, T12, TM; + E TP; + { + E T1, T18, T6, T17; + T1 = rio[0]; + T18 = iio[-WS(ios, 7)]; + { + E T3, T5, T2, T4; + T3 = rio[WS(ios, 4)]; + T5 = iio[-WS(ios, 3)]; + T2 = W[6]; + T4 = W[7]; + T6 = FMA(T2, T3, T4 * T5); + T17 = FNMS(T4, T3, T2 * T5); + } + T7 = T1 + T6; + T1e = T18 - T17; + TH = T1 - T6; + T19 = T17 + T18; + } + { + E Tz, TS, TE, TT; + { + E Tw, Ty, Tv, Tx; + Tw = rio[WS(ios, 7)]; + Ty = iio[0]; + Tv = W[12]; + Tx = W[13]; + Tz = FMA(Tv, Tw, Tx * Ty); + TS = FNMS(Tx, Tw, Tv * Ty); + } + { + E TB, TD, TA, TC; + TB = rio[WS(ios, 3)]; + TD = iio[-WS(ios, 4)]; + TA = W[4]; + TC = W[5]; + TE = FMA(TA, TB, TC * TD); + TT = FNMS(TC, TB, TA * TD); + } + TF = Tz + TE; + T13 = TS + TT; + TR = Tz - TE; + TU = TS - TT; + } + { + E Tc, TI, Th, TJ; + { + E T9, Tb, T8, Ta; + T9 = rio[WS(ios, 2)]; + Tb = iio[-WS(ios, 5)]; + T8 = W[2]; + Ta = W[3]; + Tc = FMA(T8, T9, Ta * Tb); + TI = FNMS(Ta, T9, T8 * Tb); + } + { + E Te, Tg, Td, Tf; + Te = rio[WS(ios, 6)]; + Tg = iio[-WS(ios, 1)]; + Td = W[10]; + Tf = W[11]; + Th = FMA(Td, Te, Tf * Tg); + TJ = FNMS(Tf, Te, Td * Tg); + } + Ti = Tc + Th; + T1f = Tc - Th; + TK = TI - TJ; + T16 = TI + TJ; + } + { + E To, TN, Tt, TO; + { + E Tl, Tn, Tk, Tm; + Tl = rio[WS(ios, 1)]; + Tn = iio[-WS(ios, 6)]; + Tk = W[0]; + Tm = W[1]; + To = FMA(Tk, Tl, Tm * Tn); + TN = FNMS(Tm, Tl, Tk * Tn); + } + { + E Tq, Ts, Tp, Tr; + Tq = rio[WS(ios, 5)]; + Ts = iio[-WS(ios, 2)]; + Tp = W[8]; + Tr = W[9]; + Tt = FMA(Tp, Tq, Tr * Ts); + TO = FNMS(Tr, Tq, Tp * Ts); + } + Tu = To + Tt; + T12 = TN + TO; + TM = To - Tt; + TP = TN - TO; + } + { + E Tj, TG, T1b, T1c; + Tj = T7 + Ti; + TG = Tu + TF; + iio[-WS(ios, 4)] = Tj - TG; + rio[0] = Tj + TG; + { + E T15, T1a, T11, T14; + T15 = T12 + T13; + T1a = T16 + T19; + rio[WS(ios, 4)] = T15 - T1a; + iio[0] = T15 + T1a; + T11 = T7 - Ti; + T14 = T12 - T13; + iio[-WS(ios, 6)] = T11 - T14; + rio[WS(ios, 2)] = T11 + T14; + } + T1b = TF - Tu; + T1c = T19 - T16; + rio[WS(ios, 6)] = T1b - T1c; + iio[-WS(ios, 2)] = T1b + T1c; + { + E TX, T1g, T10, T1d, TY, TZ; + TX = TH - TK; + T1g = T1e - T1f; + TY = TP - TM; + TZ = TR + TU; + T10 = KP707106781 * (TY - TZ); + T1d = KP707106781 * (TY + TZ); + iio[-WS(ios, 7)] = TX - T10; + iio[-WS(ios, 1)] = T1d + T1g; + rio[WS(ios, 3)] = TX + T10; + rio[WS(ios, 5)] = T1d - T1g; + } + { + E TL, T1i, TW, T1h, TQ, TV; + TL = TH + TK; + T1i = T1f + T1e; + TQ = TM + TP; + TV = TR - TU; + TW = KP707106781 * (TQ + TV); + T1h = KP707106781 * (TV - TQ); + iio[-WS(ios, 5)] = TL - TW; + iio[-WS(ios, 3)] = T1h + T1i; + rio[WS(ios, 1)] = TL + TW; + rio[WS(ios, 7)] = T1h - T1i; + } + } + } + return W; +} + +static const tw_instr twinstr[] = { + {TW_FULL, 0, 8}, + {TW_NEXT, 1, 0} +}; + +static const hc2hc_desc desc = { 8, "hf_8", twinstr, {52, 18, 14, 0}, &GENUS, 0, 0, 0 }; + +void X(codelet_hf_8) (planner *p) { + X(khc2hc_dit_register) (p, hf_8, &desc); +} diff --git a/src/fftw3/rdft/codelets/r2hc/hf_9.c b/src/fftw3/rdft/codelets/r2hc/hf_9.c new file mode 100644 index 0000000..167bd52 --- /dev/null +++ b/src/fftw3/rdft/codelets/r2hc/hf_9.c @@ -0,0 +1,256 @@ +/* + * 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 21:57:01 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_hc2hc -compact -variables 4 -n 9 -dit -name hf_9 -include hf.h */ + +/* + * This function contains 96 FP additions, 72 FP multiplications, + * (or, 60 additions, 36 multiplications, 36 fused multiply/add), + * 41 stack variables, and 36 memory accesses + */ +/* + * Generator Id's : + * $Id: hf_9.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: hf_9.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: hf_9.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + */ + +#include "hf.h" + +static const R *hf_9(R *rio, R *iio, const R *W, stride ios, int m, int dist) +{ + DK(KP939692620, +0.939692620785908384054109277324731469936208134); + DK(KP342020143, +0.342020143325668733044099614682259580763083368); + DK(KP984807753, +0.984807753012208059366743024589523013670643252); + DK(KP173648177, +0.173648177666930348851716626769314796000375677); + DK(KP642787609, +0.642787609686539326322643409907263432907559884); + DK(KP766044443, +0.766044443118978035202392650555416673935832457); + 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 T1, T1B, TQ, T1G, Tc, TN, T1A, T1H, TL, T1x, T17, T1o, T1c, T1n, Tu; + E T1w, TW, T1k, T11, T1l; + { + E T6, TO, Tb, TP; + T1 = rio[0]; + T1B = iio[-WS(ios, 8)]; + { + E T3, T5, T2, T4; + T3 = rio[WS(ios, 3)]; + T5 = iio[-WS(ios, 5)]; + T2 = W[4]; + T4 = W[5]; + T6 = FMA(T2, T3, T4 * T5); + TO = FNMS(T4, T3, T2 * T5); + } + { + E T8, Ta, T7, T9; + T8 = rio[WS(ios, 6)]; + Ta = iio[-WS(ios, 2)]; + T7 = W[10]; + T9 = W[11]; + Tb = FMA(T7, T8, T9 * Ta); + TP = FNMS(T9, T8, T7 * Ta); + } + TQ = KP866025403 * (TO - TP); + T1G = KP866025403 * (Tb - T6); + Tc = T6 + Tb; + TN = FNMS(KP500000000, Tc, T1); + T1A = TO + TP; + T1H = FNMS(KP500000000, T1A, T1B); + } + { + E Tz, T19, TE, T14, TJ, T15, TK, T1a; + { + E Tw, Ty, Tv, Tx; + Tw = rio[WS(ios, 2)]; + Ty = iio[-WS(ios, 6)]; + Tv = W[2]; + Tx = W[3]; + Tz = FMA(Tv, Tw, Tx * Ty); + T19 = FNMS(Tx, Tw, Tv * Ty); + } + { + E TB, TD, TA, TC; + TB = rio[WS(ios, 5)]; + TD = iio[-WS(ios, 3)]; + TA = W[8]; + TC = W[9]; + TE = FMA(TA, TB, TC * TD); + T14 = FNMS(TC, TB, TA * TD); + } + { + E TG, TI, TF, TH; + TG = rio[WS(ios, 8)]; + TI = iio[0]; + TF = W[14]; + TH = W[15]; + TJ = FMA(TF, TG, TH * TI); + T15 = FNMS(TH, TG, TF * TI); + } + TK = TE + TJ; + T1a = T14 + T15; + TL = Tz + TK; + T1x = T19 + T1a; + { + E T13, T16, T18, T1b; + T13 = FNMS(KP500000000, TK, Tz); + T16 = KP866025403 * (T14 - T15); + T17 = T13 + T16; + T1o = T13 - T16; + T18 = KP866025403 * (TJ - TE); + T1b = FNMS(KP500000000, T1a, T19); + T1c = T18 + T1b; + T1n = T1b - T18; + } + } + { + E Ti, TY, Tn, TT, Ts, TU, Tt, TZ; + { + E Tf, Th, Te, Tg; + Tf = rio[WS(ios, 1)]; + Th = iio[-WS(ios, 7)]; + Te = W[0]; + Tg = W[1]; + Ti = FMA(Te, Tf, Tg * Th); + TY = FNMS(Tg, Tf, Te * Th); + } + { + E Tk, Tm, Tj, Tl; + Tk = rio[WS(ios, 4)]; + Tm = iio[-WS(ios, 4)]; + Tj = W[6]; + Tl = W[7]; + Tn = FMA(Tj, Tk, Tl * Tm); + TT = FNMS(Tl, Tk, Tj * Tm); + } + { + E Tp, Tr, To, Tq; + Tp = rio[WS(ios, 7)]; + Tr = iio[-WS(ios, 1)]; + To = W[12]; + Tq = W[13]; + Ts = FMA(To, Tp, Tq * Tr); + TU = FNMS(Tq, Tp, To * Tr); + } + Tt = Tn + Ts; + TZ = TT + TU; + Tu = Ti + Tt; + T1w = TY + TZ; + { + E TS, TV, TX, T10; + TS = FNMS(KP500000000, Tt, Ti); + TV = KP866025403 * (TT - TU); + TW = TS + TV; + T1k = TS - TV; + TX = KP866025403 * (Ts - Tn); + T10 = FNMS(KP500000000, TZ, TY); + T11 = TX + T10; + T1l = T10 - TX; + } + } + { + E T1y, Td, TM, T1v; + T1y = KP866025403 * (T1w - T1x); + Td = T1 + Tc; + TM = Tu + TL; + T1v = FNMS(KP500000000, TM, Td); + rio[0] = Td + TM; + rio[WS(ios, 3)] = T1v + T1y; + iio[-WS(ios, 6)] = T1v - T1y; + } + { + E T1D, T1z, T1C, T1E; + T1D = KP866025403 * (TL - Tu); + T1z = T1w + T1x; + T1C = T1A + T1B; + T1E = FNMS(KP500000000, T1z, T1C); + iio[0] = T1z + T1C; + iio[-WS(ios, 3)] = T1D + T1E; + rio[WS(ios, 6)] = T1D - T1E; + } + { + E TR, T1I, T1e, T1J, T1i, T1F, T1f, T1K; + TR = TN + TQ; + T1I = T1G + T1H; + { + E T12, T1d, T1g, T1h; + T12 = FMA(KP766044443, TW, KP642787609 * T11); + T1d = FMA(KP173648177, T17, KP984807753 * T1c); + T1e = T12 + T1d; + T1J = KP866025403 * (T1d - T12); + T1g = FNMS(KP642787609, TW, KP766044443 * T11); + T1h = FNMS(KP984807753, T17, KP173648177 * T1c); + T1i = KP866025403 * (T1g - T1h); + T1F = T1g + T1h; + } + rio[WS(ios, 1)] = TR + T1e; + iio[-WS(ios, 1)] = T1F + T1I; + T1f = FNMS(KP500000000, T1e, TR); + iio[-WS(ios, 7)] = T1f - T1i; + rio[WS(ios, 4)] = T1f + T1i; + T1K = FNMS(KP500000000, T1F, T1I); + rio[WS(ios, 7)] = T1J - T1K; + iio[-WS(ios, 4)] = T1J + T1K; + } + { + E T1j, T1M, T1q, T1O, T1u, T1L, T1r, T1N; + T1j = TN - TQ; + T1M = T1H - T1G; + { + E T1m, T1p, T1s, T1t; + T1m = FMA(KP173648177, T1k, KP984807753 * T1l); + T1p = FNMS(KP939692620, T1o, KP342020143 * T1n); + T1q = T1m + T1p; + T1O = KP866025403 * (T1p - T1m); + T1s = FNMS(KP984807753, T1k, KP173648177 * T1l); + T1t = FMA(KP342020143, T1o, KP939692620 * T1n); + T1u = KP866025403 * (T1s + T1t); + T1L = T1s - T1t; + } + rio[WS(ios, 2)] = T1j + T1q; + iio[-WS(ios, 2)] = T1L + T1M; + T1r = FNMS(KP500000000, T1q, T1j); + iio[-WS(ios, 8)] = T1r - T1u; + iio[-WS(ios, 5)] = T1r + T1u; + T1N = FMS(KP500000000, T1L, T1M); + rio[WS(ios, 5)] = T1N - T1O; + rio[WS(ios, 8)] = T1O + T1N; + } + } + return W; +} + +static const tw_instr twinstr[] = { + {TW_FULL, 0, 9}, + {TW_NEXT, 1, 0} +}; + +static const hc2hc_desc desc = { 9, "hf_9", twinstr, {60, 36, 36, 0}, &GENUS, 0, 0, 0 }; + +void X(codelet_hf_9) (planner *p) { + X(khc2hc_dit_register) (p, hf_9, &desc); +} diff --git a/src/fftw3/rdft/codelets/r2hc/mr2hcII_32.c b/src/fftw3/rdft/codelets/r2hc/mr2hcII_32.c new file mode 100644 index 0000000..38c2613 --- /dev/null +++ b/src/fftw3/rdft/codelets/r2hc/mr2hcII_32.c @@ -0,0 +1,368 @@ +/* + * 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 21:58:43 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_r2hc_noinline -compact -variables 4 -n 32 -name mr2hcII_32 -dft-II -include r2hcII.h */ + +/* + * This function contains 174 FP additions, 82 FP multiplications, + * (or, 138 additions, 46 multiplications, 36 fused multiply/add), + * 61 stack variables, and 64 memory accesses + */ +/* + * Generator Id's : + * $Id: mr2hcII_32.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: mr2hcII_32.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: mr2hcII_32.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + */ + +#include "r2hcII.h" + +static void mr2hcII_32_0(const R *I, R *ro, R *io, stride is, stride ros, stride ios) +{ + DK(KP471396736, +0.471396736825997648556387625905254377657460319); + DK(KP881921264, +0.881921264348355029712756863660388349508442621); + DK(KP634393284, +0.634393284163645498215171613225493370675687095); + DK(KP773010453, +0.773010453362736960810906609758469800971041293); + DK(KP290284677, +0.290284677254462367636192375817395274691476278); + DK(KP956940335, +0.956940335732208864935797886980269969482849206); + DK(KP995184726, +0.995184726672196886244836953109479921575474869); + DK(KP098017140, +0.098017140329560601994195563888641845861136673); + 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); + { + E T5, T2D, T1z, T2q, Tc, T2C, T1C, T2n, Tm, T1k, T1J, T26, Tv, T1l, T1G; + E T27, T15, T1r, T1Y, T2e, T1c, T1s, T1V, T2d, TK, T1o, T1R, T2b, TR, T1p; + E T1O, T2a; + { + E T1, T2p, T4, T2o, T2, T3; + T1 = I[0]; + T2p = I[WS(is, 16)]; + T2 = I[WS(is, 8)]; + T3 = I[WS(is, 24)]; + T4 = KP707106781 * (T2 - T3); + T2o = KP707106781 * (T2 + T3); + T5 = T1 + T4; + T2D = T2p - T2o; + T1z = T1 - T4; + T2q = T2o + T2p; + } + { + E T8, T1A, Tb, T1B; + { + E T6, T7, T9, Ta; + T6 = I[WS(is, 4)]; + T7 = I[WS(is, 20)]; + T8 = FNMS(KP382683432, T7, KP923879532 * T6); + T1A = FMA(KP382683432, T6, KP923879532 * T7); + T9 = I[WS(is, 12)]; + Ta = I[WS(is, 28)]; + Tb = FNMS(KP923879532, Ta, KP382683432 * T9); + T1B = FMA(KP923879532, T9, KP382683432 * Ta); + } + Tc = T8 + Tb; + T2C = Tb - T8; + T1C = T1A - T1B; + T2n = T1A + T1B; + } + { + E Te, Tk, Th, Tj, Tf, Tg; + Te = I[WS(is, 2)]; + Tk = I[WS(is, 18)]; + Tf = I[WS(is, 10)]; + Tg = I[WS(is, 26)]; + Th = KP707106781 * (Tf - Tg); + Tj = KP707106781 * (Tf + Tg); + { + E Ti, Tl, T1H, T1I; + Ti = Te + Th; + Tl = Tj + Tk; + Tm = FNMS(KP195090322, Tl, KP980785280 * Ti); + T1k = FMA(KP195090322, Ti, KP980785280 * Tl); + T1H = Tk - Tj; + T1I = Te - Th; + T1J = FNMS(KP555570233, T1I, KP831469612 * T1H); + T26 = FMA(KP831469612, T1I, KP555570233 * T1H); + } + } + { + E Tq, Tt, Tp, Ts, Tn, To; + Tq = I[WS(is, 30)]; + Tt = I[WS(is, 14)]; + Tn = I[WS(is, 6)]; + To = I[WS(is, 22)]; + Tp = KP707106781 * (Tn - To); + Ts = KP707106781 * (Tn + To); + { + E Tr, Tu, T1E, T1F; + Tr = Tp - Tq; + Tu = Ts + Tt; + Tv = FMA(KP980785280, Tr, KP195090322 * Tu); + T1l = FNMS(KP980785280, Tu, KP195090322 * Tr); + T1E = Tt - Ts; + T1F = Tp + Tq; + T1G = FNMS(KP555570233, T1F, KP831469612 * T1E); + T27 = FMA(KP831469612, T1F, KP555570233 * T1E); + } + } + { + E TW, T1a, TV, T19, T10, T16, T13, T17, TT, TU; + TW = I[WS(is, 31)]; + T1a = I[WS(is, 15)]; + TT = I[WS(is, 7)]; + TU = I[WS(is, 23)]; + TV = KP707106781 * (TT - TU); + T19 = KP707106781 * (TT + TU); + { + E TY, TZ, T11, T12; + TY = I[WS(is, 3)]; + TZ = I[WS(is, 19)]; + T10 = FNMS(KP382683432, TZ, KP923879532 * TY); + T16 = FMA(KP382683432, TY, KP923879532 * TZ); + T11 = I[WS(is, 11)]; + T12 = I[WS(is, 27)]; + T13 = FNMS(KP923879532, T12, KP382683432 * T11); + T17 = FMA(KP923879532, T11, KP382683432 * T12); + } + { + E TX, T14, T1W, T1X; + TX = TV - TW; + T14 = T10 + T13; + T15 = TX + T14; + T1r = TX - T14; + T1W = T13 - T10; + T1X = T1a - T19; + T1Y = T1W - T1X; + T2e = T1W + T1X; + } + { + E T18, T1b, T1T, T1U; + T18 = T16 + T17; + T1b = T19 + T1a; + T1c = T18 + T1b; + T1s = T1b - T18; + T1T = TV + TW; + T1U = T16 - T17; + T1V = T1T + T1U; + T2d = T1U - T1T; + } + } + { + E Ty, TP, TB, TO, TF, TL, TI, TM, Tz, TA; + Ty = I[WS(is, 1)]; + TP = I[WS(is, 17)]; + Tz = I[WS(is, 9)]; + TA = I[WS(is, 25)]; + TB = KP707106781 * (Tz - TA); + TO = KP707106781 * (Tz + TA); + { + E TD, TE, TG, TH; + TD = I[WS(is, 5)]; + TE = I[WS(is, 21)]; + TF = FNMS(KP382683432, TE, KP923879532 * TD); + TL = FMA(KP382683432, TD, KP923879532 * TE); + TG = I[WS(is, 13)]; + TH = I[WS(is, 29)]; + TI = FNMS(KP923879532, TH, KP382683432 * TG); + TM = FMA(KP923879532, TG, KP382683432 * TH); + } + { + E TC, TJ, T1P, T1Q; + TC = Ty + TB; + TJ = TF + TI; + TK = TC + TJ; + T1o = TC - TJ; + T1P = TI - TF; + T1Q = TP - TO; + T1R = T1P - T1Q; + T2b = T1P + T1Q; + } + { + E TN, TQ, T1M, T1N; + TN = TL + TM; + TQ = TO + TP; + TR = TN + TQ; + T1p = TQ - TN; + T1M = Ty - TB; + T1N = TL - TM; + T1O = T1M - T1N; + T2a = T1M + T1N; + } + } + { + E Tx, T1f, T2s, T2u, T1e, T2l, T1i, T2t; + { + E Td, Tw, T2m, T2r; + Td = T5 + Tc; + Tw = Tm + Tv; + Tx = Td - Tw; + T1f = Td + Tw; + T2m = T1l - T1k; + T2r = T2n + T2q; + T2s = T2m - T2r; + T2u = T2m + T2r; + } + { + E TS, T1d, T1g, T1h; + TS = FMA(KP098017140, TK, KP995184726 * TR); + T1d = FNMS(KP995184726, T1c, KP098017140 * T15); + T1e = TS + T1d; + T2l = T1d - TS; + T1g = FNMS(KP098017140, TR, KP995184726 * TK); + T1h = FMA(KP995184726, T15, KP098017140 * T1c); + T1i = T1g + T1h; + T2t = T1h - T1g; + } + ro[WS(ros, 8)] = Tx - T1e; + io[WS(ios, 8)] = T2t - T2u; + ro[WS(ros, 7)] = Tx + T1e; + io[WS(ios, 7)] = T2t + T2u; + ro[WS(ros, 15)] = T1f - T1i; + io[WS(ios, 15)] = T2l - T2s; + ro[0] = T1f + T1i; + io[0] = T2l + T2s; + } + { + E T29, T2h, T2M, T2O, T2g, T2J, T2k, T2N; + { + E T25, T28, T2K, T2L; + T25 = T1z + T1C; + T28 = T26 - T27; + T29 = T25 + T28; + T2h = T25 - T28; + T2K = T1J + T1G; + T2L = T2C + T2D; + T2M = T2K - T2L; + T2O = T2K + T2L; + } + { + E T2c, T2f, T2i, T2j; + T2c = FMA(KP956940335, T2a, KP290284677 * T2b); + T2f = FNMS(KP290284677, T2e, KP956940335 * T2d); + T2g = T2c + T2f; + T2J = T2f - T2c; + T2i = FMA(KP290284677, T2d, KP956940335 * T2e); + T2j = FNMS(KP290284677, T2a, KP956940335 * T2b); + T2k = T2i - T2j; + T2N = T2j + T2i; + } + ro[WS(ros, 14)] = T29 - T2g; + io[WS(ios, 14)] = T2N - T2O; + ro[WS(ros, 1)] = T29 + T2g; + io[WS(ios, 1)] = T2N + T2O; + ro[WS(ros, 9)] = T2h - T2k; + io[WS(ios, 9)] = T2J - T2M; + ro[WS(ros, 6)] = T2h + T2k; + io[WS(ios, 6)] = T2J + T2M; + } + { + E T1n, T1v, T2y, T2A, T1u, T2v, T1y, T2z; + { + E T1j, T1m, T2w, T2x; + T1j = T5 - Tc; + T1m = T1k + T1l; + T1n = T1j + T1m; + T1v = T1j - T1m; + T2w = Tv - Tm; + T2x = T2q - T2n; + T2y = T2w - T2x; + T2A = T2w + T2x; + } + { + E T1q, T1t, T1w, T1x; + T1q = FMA(KP773010453, T1o, KP634393284 * T1p); + T1t = FNMS(KP634393284, T1s, KP773010453 * T1r); + T1u = T1q + T1t; + T2v = T1t - T1q; + T1w = FMA(KP634393284, T1r, KP773010453 * T1s); + T1x = FNMS(KP634393284, T1o, KP773010453 * T1p); + T1y = T1w - T1x; + T2z = T1x + T1w; + } + ro[WS(ros, 12)] = T1n - T1u; + io[WS(ios, 12)] = T2z - T2A; + ro[WS(ros, 3)] = T1n + T1u; + io[WS(ios, 3)] = T2z + T2A; + ro[WS(ros, 11)] = T1v - T1y; + io[WS(ios, 11)] = T2v - T2y; + ro[WS(ros, 4)] = T1v + T1y; + io[WS(ios, 4)] = T2v + T2y; + } + { + E T1L, T21, T2G, T2I, T20, T2H, T24, T2B; + { + E T1D, T1K, T2E, T2F; + T1D = T1z - T1C; + T1K = T1G - T1J; + T1L = T1D + T1K; + T21 = T1D - T1K; + T2E = T2C - T2D; + T2F = T26 + T27; + T2G = T2E - T2F; + T2I = T2F + T2E; + } + { + E T1S, T1Z, T22, T23; + T1S = FMA(KP881921264, T1O, KP471396736 * T1R); + T1Z = FMA(KP881921264, T1V, KP471396736 * T1Y); + T20 = T1S - T1Z; + T2H = T1S + T1Z; + T22 = FNMS(KP471396736, T1V, KP881921264 * T1Y); + T23 = FNMS(KP471396736, T1O, KP881921264 * T1R); + T24 = T22 - T23; + T2B = T23 + T22; + } + ro[WS(ros, 13)] = T1L - T20; + io[WS(ios, 13)] = T2B - T2G; + ro[WS(ros, 2)] = T1L + T20; + io[WS(ios, 2)] = T2B + T2G; + ro[WS(ros, 10)] = T21 - T24; + io[WS(ios, 10)] = T2I - T2H; + ro[WS(ros, 5)] = T21 + T24; + io[WS(ios, 5)] = -(T2H + T2I); + } + } +} + +static void mr2hcII_32(const R *I, R *ro, R *io, stride is, stride ros, stride ios, int v, int ivs, int ovs) +{ + int i; + for (i = v; i > 0; --i) { + mr2hcII_32_0(I, ro, io, is, ros, ios); + I += ivs; + ro += ovs; + io += ovs; + } +} + +static const kr2hc_desc desc = { 32, "mr2hcII_32", {138, 46, 36, 0}, &GENUS, 0, 0, 0, 0, 0 }; + +void X(codelet_mr2hcII_32) (planner *p) { + X(kr2hcII_register) (p, mr2hcII_32, &desc); +} diff --git a/src/fftw3/rdft/codelets/r2hc/mr2hcII_64.c b/src/fftw3/rdft/codelets/r2hc/mr2hcII_64.c new file mode 100644 index 0000000..4752322 --- /dev/null +++ b/src/fftw3/rdft/codelets/r2hc/mr2hcII_64.c @@ -0,0 +1,799 @@ +/* + * 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 21:59:51 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_r2hc_noinline -compact -variables 4 -n 64 -name mr2hcII_64 -dft-II -include r2hcII.h */ + +/* + * This function contains 434 FP additions, 206 FP multiplications, + * (or, 342 additions, 114 multiplications, 92 fused multiply/add), + * 117 stack variables, and 128 memory accesses + */ +/* + * Generator Id's : + * $Id: mr2hcII_64.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: mr2hcII_64.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: mr2hcII_64.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + */ + +#include "r2hcII.h" + +static void mr2hcII_64_0(const R *I, R *ro, R *io, stride is, stride ros, stride ios) +{ + DK(KP242980179, +0.242980179903263889948274162077471118320990783); + DK(KP970031253, +0.970031253194543992603984207286100251456865962); + DK(KP857728610, +0.857728610000272069902269984284770137042490799); + DK(KP514102744, +0.514102744193221726593693838968815772608049120); + DK(KP471396736, +0.471396736825997648556387625905254377657460319); + DK(KP881921264, +0.881921264348355029712756863660388349508442621); + DK(KP427555093, +0.427555093430282094320966856888798534304578629); + DK(KP903989293, +0.903989293123443331586200297230537048710132025); + DK(KP336889853, +0.336889853392220050689253212619147570477766780); + DK(KP941544065, +0.941544065183020778412509402599502357185589796); + DK(KP773010453, +0.773010453362736960810906609758469800971041293); + DK(KP634393284, +0.634393284163645498215171613225493370675687095); + DK(KP595699304, +0.595699304492433343467036528829969889511926338); + DK(KP803207531, +0.803207531480644909806676512963141923879569427); + DK(KP146730474, +0.146730474455361751658850129646717819706215317); + DK(KP989176509, +0.989176509964780973451673738016243063983689533); + DK(KP956940335, +0.956940335732208864935797886980269969482849206); + DK(KP290284677, +0.290284677254462367636192375817395274691476278); + DK(KP049067674, +0.049067674327418014254954976942682658314745363); + DK(KP998795456, +0.998795456205172392714771604759100694443203615); + DK(KP671558954, +0.671558954847018400625376850427421803228750632); + DK(KP740951125, +0.740951125354959091175616897495162729728955309); + DK(KP098017140, +0.098017140329560601994195563888641845861136673); + DK(KP995184726, +0.995184726672196886244836953109479921575474869); + DK(KP382683432, +0.382683432365089771728459984030398866761344562); + DK(KP923879532, +0.923879532511286756128183189396788286822416626); + DK(KP555570233, +0.555570233019602224742830813948532874374937191); + DK(KP831469612, +0.831469612302545237078788377617905756738560812); + DK(KP195090322, +0.195090322016128267848284868477022240927691618); + DK(KP980785280, +0.980785280403230449126182236134239036973933731); + DK(KP707106781, +0.707106781186547524400844362104849039284835938); + { + E Tm, T34, T3Z, T5g, Tv, T35, T3W, T5h, Td, T33, T6B, T6Q, T3T, T5f, T68; + E T6m, T2b, T3n, T4O, T5D, T2F, T3r, T4K, T5z, TK, T3c, T47, T5n, TR, T3b; + E T44, T5o, T15, T38, T4e, T5l, T1c, T39, T4b, T5k, T1s, T3g, T4v, T5w, T1W; + E T3k, T4k, T5s, T2u, T3q, T4R, T5A, T2y, T3o, T4H, T5C, T1L, T3j, T4y, T5t; + E T1P, T3h, T4r, T5v; + { + E Te, Tk, Th, Tj, Tf, Tg; + Te = I[WS(is, 4)]; + Tk = I[WS(is, 36)]; + Tf = I[WS(is, 20)]; + Tg = I[WS(is, 52)]; + Th = KP707106781 * (Tf - Tg); + Tj = KP707106781 * (Tf + Tg); + { + E Ti, Tl, T3X, T3Y; + Ti = Te + Th; + Tl = Tj + Tk; + Tm = FNMS(KP195090322, Tl, KP980785280 * Ti); + T34 = FMA(KP195090322, Ti, KP980785280 * Tl); + T3X = Tk - Tj; + T3Y = Te - Th; + T3Z = FNMS(KP555570233, T3Y, KP831469612 * T3X); + T5g = FMA(KP831469612, T3Y, KP555570233 * T3X); + } + } + { + E Tq, Tt, Tp, Ts, Tn, To; + Tq = I[WS(is, 60)]; + Tt = I[WS(is, 28)]; + Tn = I[WS(is, 12)]; + To = I[WS(is, 44)]; + Tp = KP707106781 * (Tn - To); + Ts = KP707106781 * (Tn + To); + { + E Tr, Tu, T3U, T3V; + Tr = Tp - Tq; + Tu = Ts + Tt; + Tv = FMA(KP980785280, Tr, KP195090322 * Tu); + T35 = FNMS(KP980785280, Tu, KP195090322 * Tr); + T3U = Tt - Ts; + T3V = Tp + Tq; + T3W = FNMS(KP555570233, T3V, KP831469612 * T3U); + T5h = FMA(KP831469612, T3V, KP555570233 * T3U); + } + } + { + E T1, T66, T4, T65, T8, T3Q, Tb, T3R, T2, T3; + T1 = I[0]; + T66 = I[WS(is, 32)]; + T2 = I[WS(is, 16)]; + T3 = I[WS(is, 48)]; + T4 = KP707106781 * (T2 - T3); + T65 = KP707106781 * (T2 + T3); + { + E T6, T7, T9, Ta; + T6 = I[WS(is, 8)]; + T7 = I[WS(is, 40)]; + T8 = FNMS(KP382683432, T7, KP923879532 * T6); + T3Q = FMA(KP382683432, T6, KP923879532 * T7); + T9 = I[WS(is, 24)]; + Ta = I[WS(is, 56)]; + Tb = FNMS(KP923879532, Ta, KP382683432 * T9); + T3R = FMA(KP923879532, T9, KP382683432 * Ta); + } + { + E T5, Tc, T6z, T6A; + T5 = T1 + T4; + Tc = T8 + Tb; + Td = T5 + Tc; + T33 = T5 - Tc; + T6z = Tb - T8; + T6A = T66 - T65; + T6B = T6z - T6A; + T6Q = T6z + T6A; + } + { + E T3P, T3S, T64, T67; + T3P = T1 - T4; + T3S = T3Q - T3R; + T3T = T3P - T3S; + T5f = T3P + T3S; + T64 = T3Q + T3R; + T67 = T65 + T66; + T68 = T64 + T67; + T6m = T67 - T64; + } + } + { + E T22, T2D, T21, T2C, T26, T2z, T29, T2A, T1Z, T20; + T22 = I[WS(is, 63)]; + T2D = I[WS(is, 31)]; + T1Z = I[WS(is, 15)]; + T20 = I[WS(is, 47)]; + T21 = KP707106781 * (T1Z - T20); + T2C = KP707106781 * (T1Z + T20); + { + E T24, T25, T27, T28; + T24 = I[WS(is, 7)]; + T25 = I[WS(is, 39)]; + T26 = FNMS(KP382683432, T25, KP923879532 * T24); + T2z = FMA(KP382683432, T24, KP923879532 * T25); + T27 = I[WS(is, 23)]; + T28 = I[WS(is, 55)]; + T29 = FNMS(KP923879532, T28, KP382683432 * T27); + T2A = FMA(KP923879532, T27, KP382683432 * T28); + } + { + E T23, T2a, T4M, T4N; + T23 = T21 - T22; + T2a = T26 + T29; + T2b = T23 + T2a; + T3n = T23 - T2a; + T4M = T29 - T26; + T4N = T2D - T2C; + T4O = T4M - T4N; + T5D = T4M + T4N; + } + { + E T2B, T2E, T4I, T4J; + T2B = T2z + T2A; + T2E = T2C + T2D; + T2F = T2B + T2E; + T3r = T2E - T2B; + T4I = T21 + T22; + T4J = T2z - T2A; + T4K = T4I + T4J; + T5z = T4J - T4I; + } + } + { + E Ty, TP, TB, TO, TF, TL, TI, TM, Tz, TA; + Ty = I[WS(is, 2)]; + TP = I[WS(is, 34)]; + Tz = I[WS(is, 18)]; + TA = I[WS(is, 50)]; + TB = KP707106781 * (Tz - TA); + TO = KP707106781 * (Tz + TA); + { + E TD, TE, TG, TH; + TD = I[WS(is, 10)]; + TE = I[WS(is, 42)]; + TF = FNMS(KP382683432, TE, KP923879532 * TD); + TL = FMA(KP382683432, TD, KP923879532 * TE); + TG = I[WS(is, 26)]; + TH = I[WS(is, 58)]; + TI = FNMS(KP923879532, TH, KP382683432 * TG); + TM = FMA(KP923879532, TG, KP382683432 * TH); + } + { + E TC, TJ, T45, T46; + TC = Ty + TB; + TJ = TF + TI; + TK = TC + TJ; + T3c = TC - TJ; + T45 = TI - TF; + T46 = TP - TO; + T47 = T45 - T46; + T5n = T45 + T46; + } + { + E TN, TQ, T42, T43; + TN = TL + TM; + TQ = TO + TP; + TR = TN + TQ; + T3b = TQ - TN; + T42 = Ty - TB; + T43 = TL - TM; + T44 = T42 - T43; + T5o = T42 + T43; + } + } + { + E TW, T1a, TV, T19, T10, T16, T13, T17, TT, TU; + TW = I[WS(is, 62)]; + T1a = I[WS(is, 30)]; + TT = I[WS(is, 14)]; + TU = I[WS(is, 46)]; + TV = KP707106781 * (TT - TU); + T19 = KP707106781 * (TT + TU); + { + E TY, TZ, T11, T12; + TY = I[WS(is, 6)]; + TZ = I[WS(is, 38)]; + T10 = FNMS(KP382683432, TZ, KP923879532 * TY); + T16 = FMA(KP382683432, TY, KP923879532 * TZ); + T11 = I[WS(is, 22)]; + T12 = I[WS(is, 54)]; + T13 = FNMS(KP923879532, T12, KP382683432 * T11); + T17 = FMA(KP923879532, T11, KP382683432 * T12); + } + { + E TX, T14, T4c, T4d; + TX = TV - TW; + T14 = T10 + T13; + T15 = TX + T14; + T38 = TX - T14; + T4c = T13 - T10; + T4d = T1a - T19; + T4e = T4c - T4d; + T5l = T4c + T4d; + } + { + E T18, T1b, T49, T4a; + T18 = T16 + T17; + T1b = T19 + T1a; + T1c = T18 + T1b; + T39 = T1b - T18; + T49 = TV + TW; + T4a = T16 - T17; + T4b = T49 + T4a; + T5k = T4a - T49; + } + } + { + E T1g, T1U, T1j, T1T, T1n, T1Q, T1q, T1R, T1h, T1i; + T1g = I[WS(is, 1)]; + T1U = I[WS(is, 33)]; + T1h = I[WS(is, 17)]; + T1i = I[WS(is, 49)]; + T1j = KP707106781 * (T1h - T1i); + T1T = KP707106781 * (T1h + T1i); + { + E T1l, T1m, T1o, T1p; + T1l = I[WS(is, 9)]; + T1m = I[WS(is, 41)]; + T1n = FNMS(KP382683432, T1m, KP923879532 * T1l); + T1Q = FMA(KP382683432, T1l, KP923879532 * T1m); + T1o = I[WS(is, 25)]; + T1p = I[WS(is, 57)]; + T1q = FNMS(KP923879532, T1p, KP382683432 * T1o); + T1R = FMA(KP923879532, T1o, KP382683432 * T1p); + } + { + E T1k, T1r, T4t, T4u; + T1k = T1g + T1j; + T1r = T1n + T1q; + T1s = T1k + T1r; + T3g = T1k - T1r; + T4t = T1q - T1n; + T4u = T1U - T1T; + T4v = T4t - T4u; + T5w = T4t + T4u; + } + { + E T1S, T1V, T4i, T4j; + T1S = T1Q + T1R; + T1V = T1T + T1U; + T1W = T1S + T1V; + T3k = T1V - T1S; + T4i = T1g - T1j; + T4j = T1Q - T1R; + T4k = T4i - T4j; + T5s = T4i + T4j; + } + } + { + E T2g, T4F, T2j, T4E, T2p, T4C, T2s, T4B; + { + E T2c, T2i, T2f, T2h, T2d, T2e; + T2c = I[WS(is, 3)]; + T2i = I[WS(is, 35)]; + T2d = I[WS(is, 19)]; + T2e = I[WS(is, 51)]; + T2f = KP707106781 * (T2d - T2e); + T2h = KP707106781 * (T2d + T2e); + T2g = T2c + T2f; + T4F = T2c - T2f; + T2j = T2h + T2i; + T4E = T2i - T2h; + } + { + E T2o, T2r, T2n, T2q, T2l, T2m; + T2o = I[WS(is, 59)]; + T2r = I[WS(is, 27)]; + T2l = I[WS(is, 11)]; + T2m = I[WS(is, 43)]; + T2n = KP707106781 * (T2l - T2m); + T2q = KP707106781 * (T2l + T2m); + T2p = T2n - T2o; + T4C = T2n + T2o; + T2s = T2q + T2r; + T4B = T2r - T2q; + } + { + E T2k, T2t, T4P, T4Q; + T2k = FNMS(KP195090322, T2j, KP980785280 * T2g); + T2t = FMA(KP980785280, T2p, KP195090322 * T2s); + T2u = T2k + T2t; + T3q = T2t - T2k; + T4P = FMA(KP831469612, T4F, KP555570233 * T4E); + T4Q = FMA(KP831469612, T4C, KP555570233 * T4B); + T4R = T4P + T4Q; + T5A = T4P - T4Q; + } + { + E T2w, T2x, T4D, T4G; + T2w = FNMS(KP980785280, T2s, KP195090322 * T2p); + T2x = FMA(KP195090322, T2g, KP980785280 * T2j); + T2y = T2w - T2x; + T3o = T2x + T2w; + T4D = FNMS(KP555570233, T4C, KP831469612 * T4B); + T4G = FNMS(KP555570233, T4F, KP831469612 * T4E); + T4H = T4D - T4G; + T5C = T4G + T4D; + } + } + { + E T1x, T4p, T1A, T4o, T1G, T4m, T1J, T4l; + { + E T1t, T1z, T1w, T1y, T1u, T1v; + T1t = I[WS(is, 5)]; + T1z = I[WS(is, 37)]; + T1u = I[WS(is, 21)]; + T1v = I[WS(is, 53)]; + T1w = KP707106781 * (T1u - T1v); + T1y = KP707106781 * (T1u + T1v); + T1x = T1t + T1w; + T4p = T1t - T1w; + T1A = T1y + T1z; + T4o = T1z - T1y; + } + { + E T1F, T1I, T1E, T1H, T1C, T1D; + T1F = I[WS(is, 61)]; + T1I = I[WS(is, 29)]; + T1C = I[WS(is, 13)]; + T1D = I[WS(is, 45)]; + T1E = KP707106781 * (T1C - T1D); + T1H = KP707106781 * (T1C + T1D); + T1G = T1E - T1F; + T4m = T1E + T1F; + T1J = T1H + T1I; + T4l = T1I - T1H; + } + { + E T1B, T1K, T4w, T4x; + T1B = FNMS(KP195090322, T1A, KP980785280 * T1x); + T1K = FMA(KP980785280, T1G, KP195090322 * T1J); + T1L = T1B + T1K; + T3j = T1K - T1B; + T4w = FMA(KP831469612, T4p, KP555570233 * T4o); + T4x = FMA(KP831469612, T4m, KP555570233 * T4l); + T4y = T4w + T4x; + T5t = T4w - T4x; + } + { + E T1N, T1O, T4n, T4q; + T1N = FNMS(KP980785280, T1J, KP195090322 * T1G); + T1O = FMA(KP195090322, T1x, KP980785280 * T1A); + T1P = T1N - T1O; + T3h = T1O + T1N; + T4n = FNMS(KP555570233, T4m, KP831469612 * T4l); + T4q = FNMS(KP555570233, T4p, KP831469612 * T4o); + T4r = T4n - T4q; + T5v = T4q + T4n; + } + } + { + E Tx, T2N, T69, T6f, T1e, T6e, T2X, T30, T1Y, T2L, T2Q, T62, T2U, T31, T2H; + E T2K, Tw, T63; + Tw = Tm + Tv; + Tx = Td + Tw; + T2N = Td - Tw; + T63 = T35 - T34; + T69 = T63 - T68; + T6f = T63 + T68; + { + E TS, T1d, T2V, T2W; + TS = FNMS(KP098017140, TR, KP995184726 * TK); + T1d = FMA(KP995184726, T15, KP098017140 * T1c); + T1e = TS + T1d; + T6e = T1d - TS; + T2V = T2b - T2u; + T2W = T2y + T2F; + T2X = FNMS(KP671558954, T2W, KP740951125 * T2V); + T30 = FMA(KP671558954, T2V, KP740951125 * T2W); + } + { + E T1M, T1X, T2O, T2P; + T1M = T1s + T1L; + T1X = T1P - T1W; + T1Y = FMA(KP998795456, T1M, KP049067674 * T1X); + T2L = FNMS(KP049067674, T1M, KP998795456 * T1X); + T2O = FMA(KP098017140, TK, KP995184726 * TR); + T2P = FNMS(KP995184726, T1c, KP098017140 * T15); + T2Q = T2O + T2P; + T62 = T2P - T2O; + } + { + E T2S, T2T, T2v, T2G; + T2S = T1s - T1L; + T2T = T1P + T1W; + T2U = FMA(KP740951125, T2S, KP671558954 * T2T); + T31 = FNMS(KP671558954, T2S, KP740951125 * T2T); + T2v = T2b + T2u; + T2G = T2y - T2F; + T2H = FNMS(KP049067674, T2G, KP998795456 * T2v); + T2K = FMA(KP049067674, T2v, KP998795456 * T2G); + } + { + E T1f, T2I, T6b, T6c; + T1f = Tx + T1e; + T2I = T1Y + T2H; + ro[WS(ros, 31)] = T1f - T2I; + ro[0] = T1f + T2I; + T6b = T2L + T2K; + T6c = T62 + T69; + io[WS(ios, 31)] = T6b - T6c; + io[0] = T6b + T6c; + } + { + E T2J, T2M, T61, T6a; + T2J = Tx - T1e; + T2M = T2K - T2L; + ro[WS(ros, 16)] = T2J - T2M; + ro[WS(ros, 15)] = T2J + T2M; + T61 = T2H - T1Y; + T6a = T62 - T69; + io[WS(ios, 16)] = T61 - T6a; + io[WS(ios, 15)] = T61 + T6a; + } + { + E T2R, T2Y, T6h, T6i; + T2R = T2N + T2Q; + T2Y = T2U + T2X; + ro[WS(ros, 24)] = T2R - T2Y; + ro[WS(ros, 7)] = T2R + T2Y; + T6h = T31 + T30; + T6i = T6e + T6f; + io[WS(ios, 24)] = T6h - T6i; + io[WS(ios, 7)] = T6h + T6i; + } + { + E T2Z, T32, T6d, T6g; + T2Z = T2N - T2Q; + T32 = T30 - T31; + ro[WS(ros, 23)] = T2Z - T32; + ro[WS(ros, 8)] = T2Z + T32; + T6d = T2X - T2U; + T6g = T6e - T6f; + io[WS(ios, 23)] = T6d - T6g; + io[WS(ios, 8)] = T6d + T6g; + } + } + { + E T5j, T5L, T6R, T6X, T5q, T6W, T5V, T5Y, T5y, T5J, T5O, T6O, T5S, T5Z, T5F; + E T5I, T5i, T6P; + T5i = T5g - T5h; + T5j = T5f - T5i; + T5L = T5f + T5i; + T6P = T3Z + T3W; + T6R = T6P - T6Q; + T6X = T6P + T6Q; + { + E T5m, T5p, T5T, T5U; + T5m = FMA(KP290284677, T5k, KP956940335 * T5l); + T5p = FNMS(KP290284677, T5o, KP956940335 * T5n); + T5q = T5m - T5p; + T6W = T5p + T5m; + T5T = T5z + T5A; + T5U = T5C + T5D; + T5V = FNMS(KP146730474, T5U, KP989176509 * T5T); + T5Y = FMA(KP146730474, T5T, KP989176509 * T5U); + } + { + E T5u, T5x, T5M, T5N; + T5u = T5s - T5t; + T5x = T5v - T5w; + T5y = FMA(KP803207531, T5u, KP595699304 * T5x); + T5J = FNMS(KP595699304, T5u, KP803207531 * T5x); + T5M = FMA(KP956940335, T5o, KP290284677 * T5n); + T5N = FNMS(KP290284677, T5l, KP956940335 * T5k); + T5O = T5M + T5N; + T6O = T5N - T5M; + } + { + E T5Q, T5R, T5B, T5E; + T5Q = T5s + T5t; + T5R = T5v + T5w; + T5S = FMA(KP989176509, T5Q, KP146730474 * T5R); + T5Z = FNMS(KP146730474, T5Q, KP989176509 * T5R); + T5B = T5z - T5A; + T5E = T5C - T5D; + T5F = FNMS(KP595699304, T5E, KP803207531 * T5B); + T5I = FMA(KP595699304, T5B, KP803207531 * T5E); + } + { + E T5r, T5G, T6T, T6U; + T5r = T5j + T5q; + T5G = T5y + T5F; + ro[WS(ros, 25)] = T5r - T5G; + ro[WS(ros, 6)] = T5r + T5G; + T6T = T5J + T5I; + T6U = T6O + T6R; + io[WS(ios, 25)] = T6T - T6U; + io[WS(ios, 6)] = T6T + T6U; + } + { + E T5H, T5K, T6N, T6S; + T5H = T5j - T5q; + T5K = T5I - T5J; + ro[WS(ros, 22)] = T5H - T5K; + ro[WS(ros, 9)] = T5H + T5K; + T6N = T5F - T5y; + T6S = T6O - T6R; + io[WS(ios, 22)] = T6N - T6S; + io[WS(ios, 9)] = T6N + T6S; + } + { + E T5P, T5W, T6Z, T70; + T5P = T5L + T5O; + T5W = T5S + T5V; + ro[WS(ros, 30)] = T5P - T5W; + ro[WS(ros, 1)] = T5P + T5W; + T6Z = T5Z + T5Y; + T70 = T6W + T6X; + io[WS(ios, 30)] = T6Z - T70; + io[WS(ios, 1)] = T6Z + T70; + } + { + E T5X, T60, T6V, T6Y; + T5X = T5L - T5O; + T60 = T5Y - T5Z; + ro[WS(ros, 17)] = T5X - T60; + ro[WS(ros, 14)] = T5X + T60; + T6V = T5V - T5S; + T6Y = T6W - T6X; + io[WS(ios, 17)] = T6V - T6Y; + io[WS(ios, 14)] = T6V + T6Y; + } + } + { + E T37, T3z, T6n, T6t, T3e, T6s, T3J, T3M, T3m, T3x, T3C, T6k, T3G, T3N, T3t; + E T3w, T36, T6l; + T36 = T34 + T35; + T37 = T33 - T36; + T3z = T33 + T36; + T6l = Tv - Tm; + T6n = T6l - T6m; + T6t = T6l + T6m; + { + E T3a, T3d, T3H, T3I; + T3a = FMA(KP634393284, T38, KP773010453 * T39); + T3d = FNMS(KP634393284, T3c, KP773010453 * T3b); + T3e = T3a - T3d; + T6s = T3d + T3a; + T3H = T3n + T3o; + T3I = T3q + T3r; + T3J = FNMS(KP336889853, T3I, KP941544065 * T3H); + T3M = FMA(KP336889853, T3H, KP941544065 * T3I); + } + { + E T3i, T3l, T3A, T3B; + T3i = T3g - T3h; + T3l = T3j - T3k; + T3m = FMA(KP903989293, T3i, KP427555093 * T3l); + T3x = FNMS(KP427555093, T3i, KP903989293 * T3l); + T3A = FMA(KP773010453, T3c, KP634393284 * T3b); + T3B = FNMS(KP634393284, T39, KP773010453 * T38); + T3C = T3A + T3B; + T6k = T3B - T3A; + } + { + E T3E, T3F, T3p, T3s; + T3E = T3g + T3h; + T3F = T3j + T3k; + T3G = FMA(KP941544065, T3E, KP336889853 * T3F); + T3N = FNMS(KP336889853, T3E, KP941544065 * T3F); + T3p = T3n - T3o; + T3s = T3q - T3r; + T3t = FNMS(KP427555093, T3s, KP903989293 * T3p); + T3w = FMA(KP427555093, T3p, KP903989293 * T3s); + } + { + E T3f, T3u, T6p, T6q; + T3f = T37 + T3e; + T3u = T3m + T3t; + ro[WS(ros, 27)] = T3f - T3u; + ro[WS(ros, 4)] = T3f + T3u; + T6p = T3x + T3w; + T6q = T6k + T6n; + io[WS(ios, 27)] = T6p - T6q; + io[WS(ios, 4)] = T6p + T6q; + } + { + E T3v, T3y, T6j, T6o; + T3v = T37 - T3e; + T3y = T3w - T3x; + ro[WS(ros, 20)] = T3v - T3y; + ro[WS(ros, 11)] = T3v + T3y; + T6j = T3t - T3m; + T6o = T6k - T6n; + io[WS(ios, 20)] = T6j - T6o; + io[WS(ios, 11)] = T6j + T6o; + } + { + E T3D, T3K, T6v, T6w; + T3D = T3z + T3C; + T3K = T3G + T3J; + ro[WS(ros, 28)] = T3D - T3K; + ro[WS(ros, 3)] = T3D + T3K; + T6v = T3N + T3M; + T6w = T6s + T6t; + io[WS(ios, 28)] = T6v - T6w; + io[WS(ios, 3)] = T6v + T6w; + } + { + E T3L, T3O, T6r, T6u; + T3L = T3z - T3C; + T3O = T3M - T3N; + ro[WS(ros, 19)] = T3L - T3O; + ro[WS(ros, 12)] = T3L + T3O; + T6r = T3J - T3G; + T6u = T6s - T6t; + io[WS(ios, 19)] = T6r - T6u; + io[WS(ios, 12)] = T6r + T6u; + } + } + { + E T41, T4Z, T6D, T6J, T4g, T6I, T59, T5d, T4A, T4X, T52, T6y, T56, T5c, T4T; + E T4W, T40, T6C; + T40 = T3W - T3Z; + T41 = T3T + T40; + T4Z = T3T - T40; + T6C = T5g + T5h; + T6D = T6B - T6C; + T6J = T6C + T6B; + { + E T48, T4f, T57, T58; + T48 = FMA(KP881921264, T44, KP471396736 * T47); + T4f = FMA(KP881921264, T4b, KP471396736 * T4e); + T4g = T48 - T4f; + T6I = T48 + T4f; + T57 = T4K + T4H; + T58 = T4R + T4O; + T59 = FMA(KP514102744, T57, KP857728610 * T58); + T5d = FNMS(KP857728610, T57, KP514102744 * T58); + } + { + E T4s, T4z, T50, T51; + T4s = T4k + T4r; + T4z = T4v - T4y; + T4A = FMA(KP970031253, T4s, KP242980179 * T4z); + T4X = FNMS(KP242980179, T4s, KP970031253 * T4z); + T50 = FNMS(KP471396736, T4b, KP881921264 * T4e); + T51 = FNMS(KP471396736, T44, KP881921264 * T47); + T52 = T50 - T51; + T6y = T51 + T50; + } + { + E T54, T55, T4L, T4S; + T54 = T4k - T4r; + T55 = T4y + T4v; + T56 = FMA(KP514102744, T54, KP857728610 * T55); + T5c = FNMS(KP514102744, T55, KP857728610 * T54); + T4L = T4H - T4K; + T4S = T4O - T4R; + T4T = FNMS(KP242980179, T4S, KP970031253 * T4L); + T4W = FMA(KP242980179, T4L, KP970031253 * T4S); + } + { + E T4h, T4U, T6F, T6G; + T4h = T41 + T4g; + T4U = T4A + T4T; + ro[WS(ros, 29)] = T4h - T4U; + ro[WS(ros, 2)] = T4h + T4U; + T6F = T4X + T4W; + T6G = T6y + T6D; + io[WS(ios, 29)] = T6F - T6G; + io[WS(ios, 2)] = T6F + T6G; + } + { + E T4V, T4Y, T6x, T6E; + T4V = T41 - T4g; + T4Y = T4W - T4X; + ro[WS(ros, 18)] = T4V - T4Y; + ro[WS(ros, 13)] = T4V + T4Y; + T6x = T4T - T4A; + T6E = T6y - T6D; + io[WS(ios, 18)] = T6x - T6E; + io[WS(ios, 13)] = T6x + T6E; + } + { + E T53, T5a, T6L, T6M; + T53 = T4Z - T52; + T5a = T56 - T59; + ro[WS(ros, 21)] = T53 - T5a; + ro[WS(ros, 10)] = T53 + T5a; + T6L = T5d - T5c; + T6M = T6J - T6I; + io[WS(ios, 21)] = T6L - T6M; + io[WS(ios, 10)] = T6L + T6M; + } + { + E T5b, T5e, T6H, T6K; + T5b = T4Z + T52; + T5e = T5c + T5d; + ro[WS(ros, 26)] = T5b - T5e; + ro[WS(ros, 5)] = T5b + T5e; + T6H = T56 + T59; + T6K = T6I + T6J; + io[WS(ios, 5)] = -(T6H + T6K); + io[WS(ios, 26)] = T6K - T6H; + } + } + } +} + +static void mr2hcII_64(const R *I, R *ro, R *io, stride is, stride ros, stride ios, int v, int ivs, int ovs) +{ + int i; + for (i = v; i > 0; --i) { + mr2hcII_64_0(I, ro, io, is, ros, ios); + I += ivs; + ro += ovs; + io += ovs; + } +} + +static const kr2hc_desc desc = { 64, "mr2hcII_64", {342, 114, 92, 0}, &GENUS, 0, 0, 0, 0, 0 }; + +void X(codelet_mr2hcII_64) (planner *p) { + X(kr2hcII_register) (p, mr2hcII_64, &desc); +} diff --git a/src/fftw3/rdft/codelets/r2hc/mr2hc_128.c b/src/fftw3/rdft/codelets/r2hc/mr2hc_128.c new file mode 100644 index 0000000..0409559 --- /dev/null +++ b/src/fftw3/rdft/codelets/r2hc/mr2hc_128.c @@ -0,0 +1,1647 @@ +/* + * 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 21:56:49 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_r2hc_noinline -compact -variables 4 -n 128 -name mr2hc_128 -include r2hc.h */ + +/* + * This function contains 956 FP additions, 330 FP multiplications, + * (or, 812 additions, 186 multiplications, 144 fused multiply/add), + * 185 stack variables, and 256 memory accesses + */ +/* + * Generator Id's : + * $Id: mr2hc_128.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: mr2hc_128.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: mr2hc_128.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + */ + +#include "r2hc.h" + +static void mr2hc_128_0(const R *I, R *ro, R *io, stride is, stride ros, stride ios) +{ + DK(KP803207531, +0.803207531480644909806676512963141923879569427); + DK(KP595699304, +0.595699304492433343467036528829969889511926338); + DK(KP146730474, +0.146730474455361751658850129646717819706215317); + DK(KP989176509, +0.989176509964780973451673738016243063983689533); + DK(KP740951125, +0.740951125354959091175616897495162729728955309); + DK(KP671558954, +0.671558954847018400625376850427421803228750632); + DK(KP049067674, +0.049067674327418014254954976942682658314745363); + DK(KP998795456, +0.998795456205172392714771604759100694443203615); + DK(KP242980179, +0.242980179903263889948274162077471118320990783); + DK(KP970031253, +0.970031253194543992603984207286100251456865962); + DK(KP514102744, +0.514102744193221726593693838968815772608049120); + DK(KP857728610, +0.857728610000272069902269984284770137042490799); + DK(KP336889853, +0.336889853392220050689253212619147570477766780); + DK(KP941544065, +0.941544065183020778412509402599502357185589796); + DK(KP427555093, +0.427555093430282094320966856888798534304578629); + DK(KP903989293, +0.903989293123443331586200297230537048710132025); + DK(KP098017140, +0.098017140329560601994195563888641845861136673); + DK(KP995184726, +0.995184726672196886244836953109479921575474869); + DK(KP634393284, +0.634393284163645498215171613225493370675687095); + DK(KP773010453, +0.773010453362736960810906609758469800971041293); + DK(KP881921264, +0.881921264348355029712756863660388349508442621); + DK(KP471396736, +0.471396736825997648556387625905254377657460319); + DK(KP956940335, +0.956940335732208864935797886980269969482849206); + DK(KP290284677, +0.290284677254462367636192375817395274691476278); + 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); + { + E TcD, TdU, T27, T7r, T5S, T8y, Tf, Ta5, Tu, Tbq, TcG, TdV, T2e, T8z, T5V; + E T7s, TK, Ta6, TcK, TdX, T2o, T5X, T7w, T8B, TZ, Ta7, TcN, TdY, T2x, T5Y; + E T7z, T8C, T1g, Taa, TcU, TeA, TcX, Tez, T1v, Tab, T2M, T6z, T7E, T9e, T7H; + E T9d, T2T, T6A, T4X, T6L, Tdz, TeL, TdK, TeP, T5G, T6P, T8d, T9p, TaV, Tc3; + E Tbi, Tc4, T8o, T9t, T3I, T6H, Tde, TeH, Tdp, TeF, T4r, T6F, T7U, T9l, Tao; + E TbW, TaL, TbX, T85, T9j, T1L, Tad, Td3, Tew, Td6, Tex, T20, Tae, T37, T6x; + E T7L, T9a, T7O, T9b, T3e, T6w, TbZ, Tc0, T3Z, T4s, Tds, TeI, T4g, T4t, T80; + E T87, Tdl, TeE, T7X, T86, TaD, TaM, Tc6, Tc7, T5e, T5H, TdN, TeM, T5v, T5I; + E T8j, T8q, TdG, TeO, T8g, T8p, Tba, Tbj; + { + E T3, T23, Td, T25, T6, T5R, Ta, T24; + { + E T1, T2, Tb, Tc; + T1 = I[0]; + T2 = I[WS(is, 64)]; + T3 = T1 + T2; + T23 = T1 - T2; + Tb = I[WS(is, 112)]; + Tc = I[WS(is, 48)]; + Td = Tb + Tc; + T25 = Tb - Tc; + } + { + E T4, T5, T8, T9; + T4 = I[WS(is, 32)]; + T5 = I[WS(is, 96)]; + T6 = T4 + T5; + T5R = T4 - T5; + T8 = I[WS(is, 16)]; + T9 = I[WS(is, 80)]; + Ta = T8 + T9; + T24 = T8 - T9; + } + TcD = T3 - T6; + TdU = Td - Ta; + { + E T26, T5Q, T7, Te; + T26 = KP707106781 * (T24 + T25); + T27 = T23 + T26; + T7r = T23 - T26; + T5Q = KP707106781 * (T25 - T24); + T5S = T5Q - T5R; + T8y = T5R + T5Q; + T7 = T3 + T6; + Te = Ta + Td; + Tf = T7 + Te; + Ta5 = T7 - Te; + } + } + { + E Ti, T28, Ts, T2c, Tl, T29, Tp, T2b; + { + E Tg, Th, Tq, Tr; + Tg = I[WS(is, 8)]; + Th = I[WS(is, 72)]; + Ti = Tg + Th; + T28 = Tg - Th; + Tq = I[WS(is, 24)]; + Tr = I[WS(is, 88)]; + Ts = Tq + Tr; + T2c = Tq - Tr; + } + { + E Tj, Tk, Tn, To; + Tj = I[WS(is, 40)]; + Tk = I[WS(is, 104)]; + Tl = Tj + Tk; + T29 = Tj - Tk; + Tn = I[WS(is, 120)]; + To = I[WS(is, 56)]; + Tp = Tn + To; + T2b = Tn - To; + } + { + E Tm, Tt, TcE, TcF; + Tm = Ti + Tl; + Tt = Tp + Ts; + Tu = Tm + Tt; + Tbq = Tt - Tm; + TcE = Ti - Tl; + TcF = Tp - Ts; + TcG = KP707106781 * (TcE + TcF); + TdV = KP707106781 * (TcF - TcE); + } + { + E T2a, T2d, T5T, T5U; + T2a = FNMS(KP382683432, T29, KP923879532 * T28); + T2d = FMA(KP923879532, T2b, KP382683432 * T2c); + T2e = T2a + T2d; + T8z = T2d - T2a; + T5T = FNMS(KP923879532, T2c, KP382683432 * T2b); + T5U = FMA(KP382683432, T28, KP923879532 * T29); + T5V = T5T - T5U; + T7s = T5U + T5T; + } + } + { + E Ty, T2g, TB, T2m, TF, T2l, TI, T2j; + { + E Tw, Tx, Tz, TA; + Tw = I[WS(is, 4)]; + Tx = I[WS(is, 68)]; + Ty = Tw + Tx; + T2g = Tw - Tx; + Tz = I[WS(is, 36)]; + TA = I[WS(is, 100)]; + TB = Tz + TA; + T2m = Tz - TA; + { + E TD, TE, T2h, TG, TH, T2i; + TD = I[WS(is, 20)]; + TE = I[WS(is, 84)]; + T2h = TD - TE; + TG = I[WS(is, 116)]; + TH = I[WS(is, 52)]; + T2i = TG - TH; + TF = TD + TE; + T2l = KP707106781 * (T2i - T2h); + TI = TG + TH; + T2j = KP707106781 * (T2h + T2i); + } + } + { + E TC, TJ, TcI, TcJ; + TC = Ty + TB; + TJ = TF + TI; + TK = TC + TJ; + Ta6 = TC - TJ; + TcI = Ty - TB; + TcJ = TI - TF; + TcK = FMA(KP923879532, TcI, KP382683432 * TcJ); + TdX = FNMS(KP382683432, TcI, KP923879532 * TcJ); + } + { + E T2k, T2n, T7u, T7v; + T2k = T2g + T2j; + T2n = T2l - T2m; + T2o = FMA(KP980785280, T2k, KP195090322 * T2n); + T5X = FNMS(KP195090322, T2k, KP980785280 * T2n); + T7u = T2g - T2j; + T7v = T2m + T2l; + T7w = FMA(KP831469612, T7u, KP555570233 * T7v); + T8B = FNMS(KP555570233, T7u, KP831469612 * T7v); + } + } + { + E TN, T2p, TQ, T2v, TU, T2u, TX, T2s; + { + E TL, TM, TO, TP; + TL = I[WS(is, 124)]; + TM = I[WS(is, 60)]; + TN = TL + TM; + T2p = TL - TM; + TO = I[WS(is, 28)]; + TP = I[WS(is, 92)]; + TQ = TO + TP; + T2v = TO - TP; + { + E TS, TT, T2q, TV, TW, T2r; + TS = I[WS(is, 12)]; + TT = I[WS(is, 76)]; + T2q = TS - TT; + TV = I[WS(is, 108)]; + TW = I[WS(is, 44)]; + T2r = TV - TW; + TU = TS + TT; + T2u = KP707106781 * (T2r - T2q); + TX = TV + TW; + T2s = KP707106781 * (T2q + T2r); + } + } + { + E TR, TY, TcL, TcM; + TR = TN + TQ; + TY = TU + TX; + TZ = TR + TY; + Ta7 = TR - TY; + TcL = TN - TQ; + TcM = TX - TU; + TcN = FNMS(KP382683432, TcM, KP923879532 * TcL); + TdY = FMA(KP382683432, TcL, KP923879532 * TcM); + } + { + E T2t, T2w, T7x, T7y; + T2t = T2p + T2s; + T2w = T2u - T2v; + T2x = FNMS(KP195090322, T2w, KP980785280 * T2t); + T5Y = FMA(KP195090322, T2t, KP980785280 * T2w); + T7x = T2p - T2s; + T7y = T2v + T2u; + T7z = FNMS(KP555570233, T7y, KP831469612 * T7x); + T8C = FMA(KP555570233, T7x, KP831469612 * T7y); + } + } + { + E T14, T2N, T17, T2D, T1b, T2O, T1e, T2C, T1j, T1m, T2K, TcR, T2Q, T1q, T1t; + E T2H, TcS, T2R; + { + E T12, T13, T15, T16; + T12 = I[WS(is, 2)]; + T13 = I[WS(is, 66)]; + T14 = T12 + T13; + T2N = T12 - T13; + T15 = I[WS(is, 34)]; + T16 = I[WS(is, 98)]; + T17 = T15 + T16; + T2D = T15 - T16; + } + { + E T19, T1a, T2B, T1c, T1d, T2A; + T19 = I[WS(is, 18)]; + T1a = I[WS(is, 82)]; + T2B = T19 - T1a; + T1c = I[WS(is, 114)]; + T1d = I[WS(is, 50)]; + T2A = T1c - T1d; + T1b = T19 + T1a; + T2O = KP707106781 * (T2B + T2A); + T1e = T1c + T1d; + T2C = KP707106781 * (T2A - T2B); + } + { + E T2I, T2J, T2F, T2G; + { + E T1h, T1i, T1k, T1l; + T1h = I[WS(is, 10)]; + T1i = I[WS(is, 74)]; + T1j = T1h + T1i; + T2I = T1h - T1i; + T1k = I[WS(is, 42)]; + T1l = I[WS(is, 106)]; + T1m = T1k + T1l; + T2J = T1k - T1l; + } + T2K = FMA(KP382683432, T2I, KP923879532 * T2J); + TcR = T1j - T1m; + T2Q = FNMS(KP382683432, T2J, KP923879532 * T2I); + { + E T1o, T1p, T1r, T1s; + T1o = I[WS(is, 122)]; + T1p = I[WS(is, 58)]; + T1q = T1o + T1p; + T2F = T1o - T1p; + T1r = I[WS(is, 26)]; + T1s = I[WS(is, 90)]; + T1t = T1r + T1s; + T2G = T1r - T1s; + } + T2H = FNMS(KP923879532, T2G, KP382683432 * T2F); + TcS = T1q - T1t; + T2R = FMA(KP923879532, T2F, KP382683432 * T2G); + } + { + E T18, T1f, TcQ, TcT; + T18 = T14 + T17; + T1f = T1b + T1e; + T1g = T18 + T1f; + Taa = T18 - T1f; + TcQ = T14 - T17; + TcT = KP707106781 * (TcR + TcS); + TcU = TcQ + TcT; + TeA = TcQ - TcT; + } + { + E TcV, TcW, T1n, T1u; + TcV = T1e - T1b; + TcW = KP707106781 * (TcS - TcR); + TcX = TcV + TcW; + Tez = TcW - TcV; + T1n = T1j + T1m; + T1u = T1q + T1t; + T1v = T1n + T1u; + Tab = T1u - T1n; + } + { + E T2E, T2L, T7C, T7D; + T2E = T2C - T2D; + T2L = T2H - T2K; + T2M = T2E + T2L; + T6z = T2L - T2E; + T7C = T2N - T2O; + T7D = T2K + T2H; + T7E = T7C + T7D; + T9e = T7C - T7D; + } + { + E T7F, T7G, T2P, T2S; + T7F = T2D + T2C; + T7G = T2R - T2Q; + T7H = T7F + T7G; + T9d = T7G - T7F; + T2P = T2N + T2O; + T2S = T2Q + T2R; + T2T = T2P + T2S; + T6A = T2P - T2S; + } + } + { + E T4z, TaP, T5B, TaQ, T4G, TaT, T5y, TaS, Tbf, Tbg, T4O, Tdw, T5E, Tbc, Tbd; + E T4V, Tdx, T5D; + { + E T4x, T4y, T5z, T5A; + T4x = I[WS(is, 127)]; + T4y = I[WS(is, 63)]; + T4z = T4x - T4y; + TaP = T4x + T4y; + T5z = I[WS(is, 31)]; + T5A = I[WS(is, 95)]; + T5B = T5z - T5A; + TaQ = T5z + T5A; + } + { + E T4A, T4B, T4C, T4D, T4E, T4F; + T4A = I[WS(is, 15)]; + T4B = I[WS(is, 79)]; + T4C = T4A - T4B; + T4D = I[WS(is, 111)]; + T4E = I[WS(is, 47)]; + T4F = T4D - T4E; + T4G = KP707106781 * (T4C + T4F); + TaT = T4D + T4E; + T5y = KP707106781 * (T4F - T4C); + TaS = T4A + T4B; + } + { + E T4K, T4N, T4R, T4U; + { + E T4I, T4J, T4L, T4M; + T4I = I[WS(is, 7)]; + T4J = I[WS(is, 71)]; + T4K = T4I - T4J; + Tbf = T4I + T4J; + T4L = I[WS(is, 39)]; + T4M = I[WS(is, 103)]; + T4N = T4L - T4M; + Tbg = T4L + T4M; + } + T4O = FNMS(KP382683432, T4N, KP923879532 * T4K); + Tdw = Tbf - Tbg; + T5E = FMA(KP382683432, T4K, KP923879532 * T4N); + { + E T4P, T4Q, T4S, T4T; + T4P = I[WS(is, 119)]; + T4Q = I[WS(is, 55)]; + T4R = T4P - T4Q; + Tbc = T4P + T4Q; + T4S = I[WS(is, 23)]; + T4T = I[WS(is, 87)]; + T4U = T4S - T4T; + Tbd = T4S + T4T; + } + T4V = FMA(KP923879532, T4R, KP382683432 * T4U); + Tdx = Tbc - Tbd; + T5D = FNMS(KP923879532, T4U, KP382683432 * T4R); + } + { + E T4H, T4W, Tdv, Tdy; + T4H = T4z + T4G; + T4W = T4O + T4V; + T4X = T4H + T4W; + T6L = T4H - T4W; + Tdv = TaP - TaQ; + Tdy = KP707106781 * (Tdw + Tdx); + Tdz = Tdv + Tdy; + TeL = Tdv - Tdy; + } + { + E TdI, TdJ, T5C, T5F; + TdI = TaT - TaS; + TdJ = KP707106781 * (Tdx - Tdw); + TdK = TdI + TdJ; + TeP = TdJ - TdI; + T5C = T5y - T5B; + T5F = T5D - T5E; + T5G = T5C + T5F; + T6P = T5F - T5C; + } + { + E T8b, T8c, TaR, TaU; + T8b = T4z - T4G; + T8c = T5E + T5D; + T8d = T8b + T8c; + T9p = T8b - T8c; + TaR = TaP + TaQ; + TaU = TaS + TaT; + TaV = TaR - TaU; + Tc3 = TaR + TaU; + } + { + E Tbe, Tbh, T8m, T8n; + Tbe = Tbc + Tbd; + Tbh = Tbf + Tbg; + Tbi = Tbe - Tbh; + Tc4 = Tbh + Tbe; + T8m = T5B + T5y; + T8n = T4V - T4O; + T8o = T8m + T8n; + T9t = T8n - T8m; + } + } + { + E T3k, Tai, T4m, Taj, T3r, Tam, T4j, Tal, TaI, TaJ, T3z, Tdb, T4p, TaF, TaG; + E T3G, Tdc, T4o; + { + E T3i, T3j, T4k, T4l; + T3i = I[WS(is, 1)]; + T3j = I[WS(is, 65)]; + T3k = T3i - T3j; + Tai = T3i + T3j; + T4k = I[WS(is, 33)]; + T4l = I[WS(is, 97)]; + T4m = T4k - T4l; + Taj = T4k + T4l; + } + { + E T3l, T3m, T3n, T3o, T3p, T3q; + T3l = I[WS(is, 17)]; + T3m = I[WS(is, 81)]; + T3n = T3l - T3m; + T3o = I[WS(is, 113)]; + T3p = I[WS(is, 49)]; + T3q = T3o - T3p; + T3r = KP707106781 * (T3n + T3q); + Tam = T3o + T3p; + T4j = KP707106781 * (T3q - T3n); + Tal = T3l + T3m; + } + { + E T3v, T3y, T3C, T3F; + { + E T3t, T3u, T3w, T3x; + T3t = I[WS(is, 9)]; + T3u = I[WS(is, 73)]; + T3v = T3t - T3u; + TaI = T3t + T3u; + T3w = I[WS(is, 41)]; + T3x = I[WS(is, 105)]; + T3y = T3w - T3x; + TaJ = T3w + T3x; + } + T3z = FNMS(KP382683432, T3y, KP923879532 * T3v); + Tdb = TaI - TaJ; + T4p = FMA(KP382683432, T3v, KP923879532 * T3y); + { + E T3A, T3B, T3D, T3E; + T3A = I[WS(is, 121)]; + T3B = I[WS(is, 57)]; + T3C = T3A - T3B; + TaF = T3A + T3B; + T3D = I[WS(is, 25)]; + T3E = I[WS(is, 89)]; + T3F = T3D - T3E; + TaG = T3D + T3E; + } + T3G = FMA(KP923879532, T3C, KP382683432 * T3F); + Tdc = TaF - TaG; + T4o = FNMS(KP923879532, T3F, KP382683432 * T3C); + } + { + E T3s, T3H, Tda, Tdd; + T3s = T3k + T3r; + T3H = T3z + T3G; + T3I = T3s + T3H; + T6H = T3s - T3H; + Tda = Tai - Taj; + Tdd = KP707106781 * (Tdb + Tdc); + Tde = Tda + Tdd; + TeH = Tda - Tdd; + } + { + E Tdn, Tdo, T4n, T4q; + Tdn = Tam - Tal; + Tdo = KP707106781 * (Tdc - Tdb); + Tdp = Tdn + Tdo; + TeF = Tdo - Tdn; + T4n = T4j - T4m; + T4q = T4o - T4p; + T4r = T4n + T4q; + T6F = T4q - T4n; + } + { + E T7S, T7T, Tak, Tan; + T7S = T3k - T3r; + T7T = T4p + T4o; + T7U = T7S + T7T; + T9l = T7S - T7T; + Tak = Tai + Taj; + Tan = Tal + Tam; + Tao = Tak - Tan; + TbW = Tak + Tan; + } + { + E TaH, TaK, T83, T84; + TaH = TaF + TaG; + TaK = TaI + TaJ; + TaL = TaH - TaK; + TbX = TaK + TaH; + T83 = T4m + T4j; + T84 = T3G - T3z; + T85 = T83 + T84; + T9j = T84 - T83; + } + } + { + E T1z, T2V, T1C, T39, T1G, T38, T1J, T2Y, T1O, T1R, T32, Td0, T3c, T1V, T1Y; + E T35, Td1, T3b; + { + E T1x, T1y, T1A, T1B; + T1x = I[WS(is, 126)]; + T1y = I[WS(is, 62)]; + T1z = T1x + T1y; + T2V = T1x - T1y; + T1A = I[WS(is, 30)]; + T1B = I[WS(is, 94)]; + T1C = T1A + T1B; + T39 = T1A - T1B; + } + { + E T1E, T1F, T2W, T1H, T1I, T2X; + T1E = I[WS(is, 14)]; + T1F = I[WS(is, 78)]; + T2W = T1E - T1F; + T1H = I[WS(is, 110)]; + T1I = I[WS(is, 46)]; + T2X = T1H - T1I; + T1G = T1E + T1F; + T38 = KP707106781 * (T2X - T2W); + T1J = T1H + T1I; + T2Y = KP707106781 * (T2W + T2X); + } + { + E T30, T31, T33, T34; + { + E T1M, T1N, T1P, T1Q; + T1M = I[WS(is, 6)]; + T1N = I[WS(is, 70)]; + T1O = T1M + T1N; + T30 = T1M - T1N; + T1P = I[WS(is, 38)]; + T1Q = I[WS(is, 102)]; + T1R = T1P + T1Q; + T31 = T1P - T1Q; + } + T32 = FNMS(KP382683432, T31, KP923879532 * T30); + Td0 = T1O - T1R; + T3c = FMA(KP382683432, T30, KP923879532 * T31); + { + E T1T, T1U, T1W, T1X; + T1T = I[WS(is, 118)]; + T1U = I[WS(is, 54)]; + T1V = T1T + T1U; + T33 = T1T - T1U; + T1W = I[WS(is, 22)]; + T1X = I[WS(is, 86)]; + T1Y = T1W + T1X; + T34 = T1W - T1X; + } + T35 = FMA(KP923879532, T33, KP382683432 * T34); + Td1 = T1V - T1Y; + T3b = FNMS(KP923879532, T34, KP382683432 * T33); + } + { + E T1D, T1K, TcZ, Td2; + T1D = T1z + T1C; + T1K = T1G + T1J; + T1L = T1D + T1K; + Tad = T1D - T1K; + TcZ = T1z - T1C; + Td2 = KP707106781 * (Td0 + Td1); + Td3 = TcZ + Td2; + Tew = TcZ - Td2; + } + { + E Td4, Td5, T1S, T1Z; + Td4 = T1J - T1G; + Td5 = KP707106781 * (Td1 - Td0); + Td6 = Td4 + Td5; + Tex = Td5 - Td4; + T1S = T1O + T1R; + T1Z = T1V + T1Y; + T20 = T1S + T1Z; + Tae = T1Z - T1S; + } + { + E T2Z, T36, T7J, T7K; + T2Z = T2V + T2Y; + T36 = T32 + T35; + T37 = T2Z + T36; + T6x = T2Z - T36; + T7J = T2V - T2Y; + T7K = T3c + T3b; + T7L = T7J + T7K; + T9a = T7J - T7K; + } + { + E T7M, T7N, T3a, T3d; + T7M = T39 + T38; + T7N = T35 - T32; + T7O = T7M + T7N; + T9b = T7N - T7M; + T3a = T38 - T39; + T3d = T3b - T3c; + T3e = T3a + T3d; + T6w = T3d - T3a; + } + } + { + E T3L, Tdf, T3X, Tar, T42, Tdi, T4e, Tay, T3S, Tdg, T3U, Tau, T49, Tdj, T4b; + E TaB, Tdh, Tdk; + { + E T3J, T3K, Tap, T3V, T3W, Taq; + T3J = I[WS(is, 5)]; + T3K = I[WS(is, 69)]; + Tap = T3J + T3K; + T3V = I[WS(is, 37)]; + T3W = I[WS(is, 101)]; + Taq = T3V + T3W; + T3L = T3J - T3K; + Tdf = Tap - Taq; + T3X = T3V - T3W; + Tar = Tap + Taq; + } + { + E T40, T41, Taw, T4c, T4d, Tax; + T40 = I[WS(is, 125)]; + T41 = I[WS(is, 61)]; + Taw = T40 + T41; + T4c = I[WS(is, 29)]; + T4d = I[WS(is, 93)]; + Tax = T4c + T4d; + T42 = T40 - T41; + Tdi = Taw - Tax; + T4e = T4c - T4d; + Tay = Taw + Tax; + } + { + E T3O, Tas, T3R, Tat; + { + E T3M, T3N, T3P, T3Q; + T3M = I[WS(is, 21)]; + T3N = I[WS(is, 85)]; + T3O = T3M - T3N; + Tas = T3M + T3N; + T3P = I[WS(is, 117)]; + T3Q = I[WS(is, 53)]; + T3R = T3P - T3Q; + Tat = T3P + T3Q; + } + T3S = KP707106781 * (T3O + T3R); + Tdg = Tat - Tas; + T3U = KP707106781 * (T3R - T3O); + Tau = Tas + Tat; + } + { + E T45, Taz, T48, TaA; + { + E T43, T44, T46, T47; + T43 = I[WS(is, 13)]; + T44 = I[WS(is, 77)]; + T45 = T43 - T44; + Taz = T43 + T44; + T46 = I[WS(is, 109)]; + T47 = I[WS(is, 45)]; + T48 = T46 - T47; + TaA = T46 + T47; + } + T49 = KP707106781 * (T45 + T48); + Tdj = TaA - Taz; + T4b = KP707106781 * (T48 - T45); + TaB = Taz + TaA; + } + TbZ = Tar + Tau; + Tc0 = Tay + TaB; + { + E T3T, T3Y, Tdq, Tdr; + T3T = T3L + T3S; + T3Y = T3U - T3X; + T3Z = FMA(KP980785280, T3T, KP195090322 * T3Y); + T4s = FNMS(KP195090322, T3T, KP980785280 * T3Y); + Tdq = FNMS(KP382683432, Tdf, KP923879532 * Tdg); + Tdr = FMA(KP382683432, Tdi, KP923879532 * Tdj); + Tds = Tdq + Tdr; + TeI = Tdr - Tdq; + } + { + E T4a, T4f, T7Y, T7Z; + T4a = T42 + T49; + T4f = T4b - T4e; + T4g = FNMS(KP195090322, T4f, KP980785280 * T4a); + T4t = FMA(KP195090322, T4a, KP980785280 * T4f); + T7Y = T42 - T49; + T7Z = T4e + T4b; + T80 = FNMS(KP555570233, T7Z, KP831469612 * T7Y); + T87 = FMA(KP555570233, T7Y, KP831469612 * T7Z); + } + Tdh = FMA(KP923879532, Tdf, KP382683432 * Tdg); + Tdk = FNMS(KP382683432, Tdj, KP923879532 * Tdi); + Tdl = Tdh + Tdk; + TeE = Tdk - Tdh; + { + E T7V, T7W, Tav, TaC; + T7V = T3L - T3S; + T7W = T3X + T3U; + T7X = FMA(KP831469612, T7V, KP555570233 * T7W); + T86 = FNMS(KP555570233, T7V, KP831469612 * T7W); + Tav = Tar - Tau; + TaC = Tay - TaB; + TaD = KP707106781 * (Tav + TaC); + TaM = KP707106781 * (TaC - Tav); + } + } + { + E T50, TdA, T5c, TaY, T5h, TdD, T5t, Tb5, T57, TdB, T59, Tb1, T5o, TdE, T5q; + E Tb8, TdC, TdF; + { + E T4Y, T4Z, TaW, T5a, T5b, TaX; + T4Y = I[WS(is, 3)]; + T4Z = I[WS(is, 67)]; + TaW = T4Y + T4Z; + T5a = I[WS(is, 35)]; + T5b = I[WS(is, 99)]; + TaX = T5a + T5b; + T50 = T4Y - T4Z; + TdA = TaW - TaX; + T5c = T5a - T5b; + TaY = TaW + TaX; + } + { + E T5f, T5g, Tb3, T5r, T5s, Tb4; + T5f = I[WS(is, 123)]; + T5g = I[WS(is, 59)]; + Tb3 = T5f + T5g; + T5r = I[WS(is, 27)]; + T5s = I[WS(is, 91)]; + Tb4 = T5r + T5s; + T5h = T5f - T5g; + TdD = Tb3 - Tb4; + T5t = T5r - T5s; + Tb5 = Tb3 + Tb4; + } + { + E T53, TaZ, T56, Tb0; + { + E T51, T52, T54, T55; + T51 = I[WS(is, 19)]; + T52 = I[WS(is, 83)]; + T53 = T51 - T52; + TaZ = T51 + T52; + T54 = I[WS(is, 115)]; + T55 = I[WS(is, 51)]; + T56 = T54 - T55; + Tb0 = T54 + T55; + } + T57 = KP707106781 * (T53 + T56); + TdB = Tb0 - TaZ; + T59 = KP707106781 * (T56 - T53); + Tb1 = TaZ + Tb0; + } + { + E T5k, Tb6, T5n, Tb7; + { + E T5i, T5j, T5l, T5m; + T5i = I[WS(is, 11)]; + T5j = I[WS(is, 75)]; + T5k = T5i - T5j; + Tb6 = T5i + T5j; + T5l = I[WS(is, 107)]; + T5m = I[WS(is, 43)]; + T5n = T5l - T5m; + Tb7 = T5l + T5m; + } + T5o = KP707106781 * (T5k + T5n); + TdE = Tb7 - Tb6; + T5q = KP707106781 * (T5n - T5k); + Tb8 = Tb6 + Tb7; + } + Tc6 = TaY + Tb1; + Tc7 = Tb5 + Tb8; + { + E T58, T5d, TdL, TdM; + T58 = T50 + T57; + T5d = T59 - T5c; + T5e = FMA(KP980785280, T58, KP195090322 * T5d); + T5H = FNMS(KP195090322, T58, KP980785280 * T5d); + TdL = FNMS(KP382683432, TdA, KP923879532 * TdB); + TdM = FMA(KP382683432, TdD, KP923879532 * TdE); + TdN = TdL + TdM; + TeM = TdM - TdL; + } + { + E T5p, T5u, T8h, T8i; + T5p = T5h + T5o; + T5u = T5q - T5t; + T5v = FNMS(KP195090322, T5u, KP980785280 * T5p); + T5I = FMA(KP195090322, T5p, KP980785280 * T5u); + T8h = T5h - T5o; + T8i = T5t + T5q; + T8j = FNMS(KP555570233, T8i, KP831469612 * T8h); + T8q = FMA(KP555570233, T8h, KP831469612 * T8i); + } + TdC = FMA(KP923879532, TdA, KP382683432 * TdB); + TdF = FNMS(KP382683432, TdE, KP923879532 * TdD); + TdG = TdC + TdF; + TeO = TdF - TdC; + { + E T8e, T8f, Tb2, Tb9; + T8e = T50 - T57; + T8f = T5c + T59; + T8g = FMA(KP831469612, T8e, KP555570233 * T8f); + T8p = FNMS(KP555570233, T8e, KP831469612 * T8f); + Tb2 = TaY - Tb1; + Tb9 = Tb5 - Tb8; + Tba = KP707106781 * (Tb2 + Tb9); + Tbj = KP707106781 * (Tb9 - Tb2); + } + } + { + E T11, TbV, Tc9, Tcf, T22, Tcb, Tc2, Tce; + { + E Tv, T10, Tc5, Tc8; + Tv = Tf + Tu; + T10 = TK + TZ; + T11 = Tv + T10; + TbV = Tv - T10; + Tc5 = Tc3 + Tc4; + Tc8 = Tc6 + Tc7; + Tc9 = Tc5 - Tc8; + Tcf = Tc5 + Tc8; + } + { + E T1w, T21, TbY, Tc1; + T1w = T1g + T1v; + T21 = T1L + T20; + T22 = T1w + T21; + Tcb = T21 - T1w; + TbY = TbW + TbX; + Tc1 = TbZ + Tc0; + Tc2 = TbY - Tc1; + Tce = TbY + Tc1; + } + ro[WS(ros, 32)] = T11 - T22; + io[WS(ios, 32)] = Tcf - Tce; + { + E Tca, Tcc, Tcd, Tcg; + Tca = KP707106781 * (Tc2 + Tc9); + ro[WS(ros, 48)] = TbV - Tca; + ro[WS(ros, 16)] = TbV + Tca; + Tcc = KP707106781 * (Tc9 - Tc2); + io[WS(ios, 16)] = Tcb + Tcc; + io[WS(ios, 48)] = Tcc - Tcb; + Tcd = T11 + T22; + Tcg = Tce + Tcf; + ro[WS(ros, 64)] = Tcd - Tcg; + ro[0] = Tcd + Tcg; + } + } + { + E Tch, Tcu, Tck, Tct, Tco, Tcy, Tcr, Tcz, Tci, Tcj; + Tch = Tf - Tu; + Tcu = TZ - TK; + Tci = T1g - T1v; + Tcj = T1L - T20; + Tck = KP707106781 * (Tci + Tcj); + Tct = KP707106781 * (Tcj - Tci); + { + E Tcm, Tcn, Tcp, Tcq; + Tcm = TbW - TbX; + Tcn = Tc0 - TbZ; + Tco = FMA(KP923879532, Tcm, KP382683432 * Tcn); + Tcy = FNMS(KP382683432, Tcm, KP923879532 * Tcn); + Tcp = Tc3 - Tc4; + Tcq = Tc7 - Tc6; + Tcr = FNMS(KP382683432, Tcq, KP923879532 * Tcp); + Tcz = FMA(KP382683432, Tcp, KP923879532 * Tcq); + } + { + E Tcl, Tcs, Tcx, TcA; + Tcl = Tch + Tck; + Tcs = Tco + Tcr; + ro[WS(ros, 56)] = Tcl - Tcs; + ro[WS(ros, 8)] = Tcl + Tcs; + Tcx = Tcu + Tct; + TcA = Tcy + Tcz; + io[WS(ios, 8)] = Tcx + TcA; + io[WS(ios, 56)] = TcA - Tcx; + } + { + E Tcv, Tcw, TcB, TcC; + Tcv = Tct - Tcu; + Tcw = Tcr - Tco; + io[WS(ios, 24)] = Tcv + Tcw; + io[WS(ios, 40)] = Tcw - Tcv; + TcB = Tch - Tck; + TcC = Tcz - Tcy; + ro[WS(ros, 40)] = TcB - TcC; + ro[WS(ros, 24)] = TcB + TcC; + } + } + { + E Ta9, TbB, Tbs, TbM, Tag, TbL, TbJ, TbR, TaO, Tbw, Tbp, TbC, TbG, TbQ, Tbl; + E Tbx, Ta8, Tbr; + Ta8 = KP707106781 * (Ta6 + Ta7); + Ta9 = Ta5 + Ta8; + TbB = Ta5 - Ta8; + Tbr = KP707106781 * (Ta7 - Ta6); + Tbs = Tbq + Tbr; + TbM = Tbr - Tbq; + { + E Tac, Taf, TbH, TbI; + Tac = FMA(KP923879532, Taa, KP382683432 * Tab); + Taf = FNMS(KP382683432, Tae, KP923879532 * Tad); + Tag = Tac + Taf; + TbL = Taf - Tac; + TbH = TaV - Tba; + TbI = Tbj - Tbi; + TbJ = FNMS(KP555570233, TbI, KP831469612 * TbH); + TbR = FMA(KP555570233, TbH, KP831469612 * TbI); + } + { + E TaE, TaN, Tbn, Tbo; + TaE = Tao + TaD; + TaN = TaL + TaM; + TaO = FMA(KP980785280, TaE, KP195090322 * TaN); + Tbw = FNMS(KP195090322, TaE, KP980785280 * TaN); + Tbn = FNMS(KP382683432, Taa, KP923879532 * Tab); + Tbo = FMA(KP382683432, Tad, KP923879532 * Tae); + Tbp = Tbn + Tbo; + TbC = Tbo - Tbn; + } + { + E TbE, TbF, Tbb, Tbk; + TbE = Tao - TaD; + TbF = TaM - TaL; + TbG = FMA(KP831469612, TbE, KP555570233 * TbF); + TbQ = FNMS(KP555570233, TbE, KP831469612 * TbF); + Tbb = TaV + Tba; + Tbk = Tbi + Tbj; + Tbl = FNMS(KP195090322, Tbk, KP980785280 * Tbb); + Tbx = FMA(KP195090322, Tbb, KP980785280 * Tbk); + } + { + E Tah, Tbm, Tbv, Tby; + Tah = Ta9 + Tag; + Tbm = TaO + Tbl; + ro[WS(ros, 60)] = Tah - Tbm; + ro[WS(ros, 4)] = Tah + Tbm; + Tbv = Tbs + Tbp; + Tby = Tbw + Tbx; + io[WS(ios, 4)] = Tbv + Tby; + io[WS(ios, 60)] = Tby - Tbv; + } + { + E Tbt, Tbu, Tbz, TbA; + Tbt = Tbp - Tbs; + Tbu = Tbl - TaO; + io[WS(ios, 28)] = Tbt + Tbu; + io[WS(ios, 36)] = Tbu - Tbt; + Tbz = Ta9 - Tag; + TbA = Tbx - Tbw; + ro[WS(ros, 36)] = Tbz - TbA; + ro[WS(ros, 28)] = Tbz + TbA; + } + { + E TbD, TbK, TbP, TbS; + TbD = TbB + TbC; + TbK = TbG + TbJ; + ro[WS(ros, 52)] = TbD - TbK; + ro[WS(ros, 12)] = TbD + TbK; + TbP = TbM + TbL; + TbS = TbQ + TbR; + io[WS(ios, 12)] = TbP + TbS; + io[WS(ios, 52)] = TbS - TbP; + } + { + E TbN, TbO, TbT, TbU; + TbN = TbL - TbM; + TbO = TbJ - TbG; + io[WS(ios, 20)] = TbN + TbO; + io[WS(ios, 44)] = TbO - TbN; + TbT = TbB - TbC; + TbU = TbR - TbQ; + ro[WS(ros, 44)] = TbT - TbU; + ro[WS(ros, 20)] = TbT + TbU; + } + } + { + E Tev, Tf7, Tfc, Tfm, Tff, Tfn, TeC, Tfh, TeK, Tf2, TeV, Tf8, TeY, Tfi, TeR; + E Tf3; + { + E Tet, Teu, Tfa, Tfb; + Tet = TcD - TcG; + Teu = TdY - TdX; + Tev = Tet - Teu; + Tf7 = Tet + Teu; + Tfa = TeF + TeE; + Tfb = TeH + TeI; + Tfc = FMA(KP290284677, Tfa, KP956940335 * Tfb); + Tfm = FNMS(KP290284677, Tfb, KP956940335 * Tfa); + } + { + E Tfd, Tfe, Tey, TeB; + Tfd = TeL + TeM; + Tfe = TeP + TeO; + Tff = FNMS(KP290284677, Tfe, KP956940335 * Tfd); + Tfn = FMA(KP956940335, Tfe, KP290284677 * Tfd); + Tey = FMA(KP555570233, Tew, KP831469612 * Tex); + TeB = FNMS(KP555570233, TeA, KP831469612 * Tez); + TeC = Tey - TeB; + Tfh = TeB + Tey; + } + { + E TeG, TeJ, TeT, TeU; + TeG = TeE - TeF; + TeJ = TeH - TeI; + TeK = FMA(KP471396736, TeG, KP881921264 * TeJ); + Tf2 = FNMS(KP471396736, TeJ, KP881921264 * TeG); + TeT = FNMS(KP555570233, Tex, KP831469612 * Tew); + TeU = FMA(KP831469612, TeA, KP555570233 * Tez); + TeV = TeT - TeU; + Tf8 = TeU + TeT; + } + { + E TeW, TeX, TeN, TeQ; + TeW = TcN - TcK; + TeX = TdV - TdU; + TeY = TeW - TeX; + Tfi = TeX + TeW; + TeN = TeL - TeM; + TeQ = TeO - TeP; + TeR = FNMS(KP471396736, TeQ, KP881921264 * TeN); + Tf3 = FMA(KP881921264, TeQ, KP471396736 * TeN); + } + { + E TeD, TeS, Tf1, Tf4; + TeD = Tev + TeC; + TeS = TeK + TeR; + ro[WS(ros, 54)] = TeD - TeS; + ro[WS(ros, 10)] = TeD + TeS; + Tf1 = TeY + TeV; + Tf4 = Tf2 + Tf3; + io[WS(ios, 10)] = Tf1 + Tf4; + io[WS(ios, 54)] = Tf4 - Tf1; + } + { + E TeZ, Tf0, Tf5, Tf6; + TeZ = TeV - TeY; + Tf0 = TeR - TeK; + io[WS(ios, 22)] = TeZ + Tf0; + io[WS(ios, 42)] = Tf0 - TeZ; + Tf5 = Tev - TeC; + Tf6 = Tf3 - Tf2; + ro[WS(ros, 42)] = Tf5 - Tf6; + ro[WS(ros, 22)] = Tf5 + Tf6; + } + { + E Tf9, Tfg, Tfl, Tfo; + Tf9 = Tf7 + Tf8; + Tfg = Tfc + Tff; + ro[WS(ros, 58)] = Tf9 - Tfg; + ro[WS(ros, 6)] = Tf9 + Tfg; + Tfl = Tfi + Tfh; + Tfo = Tfm + Tfn; + io[WS(ios, 6)] = Tfl + Tfo; + io[WS(ios, 58)] = Tfo - Tfl; + } + { + E Tfj, Tfk, Tfp, Tfq; + Tfj = Tfh - Tfi; + Tfk = Tff - Tfc; + io[WS(ios, 26)] = Tfj + Tfk; + io[WS(ios, 38)] = Tfk - Tfj; + Tfp = Tf7 - Tf8; + Tfq = Tfn - Tfm; + ro[WS(ros, 38)] = Tfp - Tfq; + ro[WS(ros, 26)] = Tfp + Tfq; + } + } + { + E TcP, Te9, Tee, Teo, Teh, Tep, Td8, Tej, Tdu, Te4, TdT, Tea, Te0, Tek, TdP; + E Te5; + { + E TcH, TcO, Tec, Ted; + TcH = TcD + TcG; + TcO = TcK + TcN; + TcP = TcH + TcO; + Te9 = TcH - TcO; + Tec = Tde - Tdl; + Ted = Tds - Tdp; + Tee = FMA(KP773010453, Tec, KP634393284 * Ted); + Teo = FNMS(KP634393284, Tec, KP773010453 * Ted); + } + { + E Tef, Teg, TcY, Td7; + Tef = Tdz - TdG; + Teg = TdN - TdK; + Teh = FNMS(KP634393284, Teg, KP773010453 * Tef); + Tep = FMA(KP634393284, Tef, KP773010453 * Teg); + TcY = FMA(KP980785280, TcU, KP195090322 * TcX); + Td7 = FNMS(KP195090322, Td6, KP980785280 * Td3); + Td8 = TcY + Td7; + Tej = Td7 - TcY; + } + { + E Tdm, Tdt, TdR, TdS; + Tdm = Tde + Tdl; + Tdt = Tdp + Tds; + Tdu = FMA(KP995184726, Tdm, KP098017140 * Tdt); + Te4 = FNMS(KP098017140, Tdm, KP995184726 * Tdt); + TdR = FNMS(KP195090322, TcU, KP980785280 * TcX); + TdS = FMA(KP195090322, Td3, KP980785280 * Td6); + TdT = TdR + TdS; + Tea = TdS - TdR; + } + { + E TdW, TdZ, TdH, TdO; + TdW = TdU + TdV; + TdZ = TdX + TdY; + Te0 = TdW + TdZ; + Tek = TdZ - TdW; + TdH = Tdz + TdG; + TdO = TdK + TdN; + TdP = FNMS(KP098017140, TdO, KP995184726 * TdH); + Te5 = FMA(KP098017140, TdH, KP995184726 * TdO); + } + { + E Td9, TdQ, Te3, Te6; + Td9 = TcP + Td8; + TdQ = Tdu + TdP; + ro[WS(ros, 62)] = Td9 - TdQ; + ro[WS(ros, 2)] = Td9 + TdQ; + Te3 = Te0 + TdT; + Te6 = Te4 + Te5; + io[WS(ios, 2)] = Te3 + Te6; + io[WS(ios, 62)] = Te6 - Te3; + } + { + E Te1, Te2, Te7, Te8; + Te1 = TdT - Te0; + Te2 = TdP - Tdu; + io[WS(ios, 30)] = Te1 + Te2; + io[WS(ios, 34)] = Te2 - Te1; + Te7 = TcP - Td8; + Te8 = Te5 - Te4; + ro[WS(ros, 34)] = Te7 - Te8; + ro[WS(ros, 30)] = Te7 + Te8; + } + { + E Teb, Tei, Ten, Teq; + Teb = Te9 + Tea; + Tei = Tee + Teh; + ro[WS(ros, 50)] = Teb - Tei; + ro[WS(ros, 14)] = Teb + Tei; + Ten = Tek + Tej; + Teq = Teo + Tep; + io[WS(ios, 14)] = Ten + Teq; + io[WS(ios, 50)] = Teq - Ten; + } + { + E Tel, Tem, Ter, Tes; + Tel = Tej - Tek; + Tem = Teh - Tee; + io[WS(ios, 18)] = Tel + Tem; + io[WS(ios, 46)] = Tem - Tel; + Ter = Te9 - Tea; + Tes = Tep - Teo; + ro[WS(ros, 46)] = Ter - Tes; + ro[WS(ros, 18)] = Ter + Tes; + } + } + { + E T6v, T77, T6C, T7h, T6Y, T7i, T6V, T78, T6R, T7n, T73, T7f, T6K, T7m, T72; + E T7c; + { + E T6t, T6u, T6T, T6U; + T6t = T27 - T2e; + T6u = T5Y - T5X; + T6v = T6t - T6u; + T77 = T6t + T6u; + { + E T6y, T6B, T6W, T6X; + T6y = FMA(KP773010453, T6w, KP634393284 * T6x); + T6B = FNMS(KP634393284, T6A, KP773010453 * T6z); + T6C = T6y - T6B; + T7h = T6B + T6y; + T6W = T2x - T2o; + T6X = T5V - T5S; + T6Y = T6W - T6X; + T7i = T6X + T6W; + } + T6T = FNMS(KP634393284, T6w, KP773010453 * T6x); + T6U = FMA(KP634393284, T6z, KP773010453 * T6A); + T6V = T6T - T6U; + T78 = T6U + T6T; + { + E T6N, T7d, T6Q, T7e, T6M, T6O; + T6M = T5I - T5H; + T6N = T6L - T6M; + T7d = T6L + T6M; + T6O = T5v - T5e; + T6Q = T6O - T6P; + T7e = T6P + T6O; + T6R = FNMS(KP427555093, T6Q, KP903989293 * T6N); + T7n = FMA(KP941544065, T7e, KP336889853 * T7d); + T73 = FMA(KP903989293, T6Q, KP427555093 * T6N); + T7f = FNMS(KP336889853, T7e, KP941544065 * T7d); + } + { + E T6G, T7a, T6J, T7b, T6E, T6I; + T6E = T4g - T3Z; + T6G = T6E - T6F; + T7a = T6F + T6E; + T6I = T4t - T4s; + T6J = T6H - T6I; + T7b = T6H + T6I; + T6K = FMA(KP427555093, T6G, KP903989293 * T6J); + T7m = FNMS(KP336889853, T7b, KP941544065 * T7a); + T72 = FNMS(KP427555093, T6J, KP903989293 * T6G); + T7c = FMA(KP336889853, T7a, KP941544065 * T7b); + } + } + { + E T6D, T6S, T71, T74; + T6D = T6v + T6C; + T6S = T6K + T6R; + ro[WS(ros, 55)] = T6D - T6S; + ro[WS(ros, 9)] = T6D + T6S; + T71 = T6Y + T6V; + T74 = T72 + T73; + io[WS(ios, 9)] = T71 + T74; + io[WS(ios, 55)] = T74 - T71; + } + { + E T6Z, T70, T75, T76; + T6Z = T6V - T6Y; + T70 = T6R - T6K; + io[WS(ios, 23)] = T6Z + T70; + io[WS(ios, 41)] = T70 - T6Z; + T75 = T6v - T6C; + T76 = T73 - T72; + ro[WS(ros, 41)] = T75 - T76; + ro[WS(ros, 23)] = T75 + T76; + } + { + E T79, T7g, T7l, T7o; + T79 = T77 + T78; + T7g = T7c + T7f; + ro[WS(ros, 57)] = T79 - T7g; + ro[WS(ros, 7)] = T79 + T7g; + T7l = T7i + T7h; + T7o = T7m + T7n; + io[WS(ios, 7)] = T7l + T7o; + io[WS(ios, 57)] = T7o - T7l; + } + { + E T7j, T7k, T7p, T7q; + T7j = T7h - T7i; + T7k = T7f - T7c; + io[WS(ios, 25)] = T7j + T7k; + io[WS(ios, 39)] = T7k - T7j; + T7p = T77 - T78; + T7q = T7n - T7m; + ro[WS(ros, 39)] = T7p - T7q; + ro[WS(ros, 25)] = T7p + T7q; + } + } + { + E T99, T9L, T9g, T9V, T9C, T9W, T9z, T9M, T9v, Ta1, T9H, T9T, T9o, Ta0, T9G; + E T9Q; + { + E T97, T98, T9x, T9y; + T97 = T7r - T7s; + T98 = T8C - T8B; + T99 = T97 - T98; + T9L = T97 + T98; + { + E T9c, T9f, T9A, T9B; + T9c = FMA(KP471396736, T9a, KP881921264 * T9b); + T9f = FNMS(KP471396736, T9e, KP881921264 * T9d); + T9g = T9c - T9f; + T9V = T9f + T9c; + T9A = T7z - T7w; + T9B = T8z - T8y; + T9C = T9A - T9B; + T9W = T9B + T9A; + } + T9x = FNMS(KP471396736, T9b, KP881921264 * T9a); + T9y = FMA(KP881921264, T9e, KP471396736 * T9d); + T9z = T9x - T9y; + T9M = T9y + T9x; + { + E T9r, T9R, T9u, T9S, T9q, T9s; + T9q = T8q - T8p; + T9r = T9p - T9q; + T9R = T9p + T9q; + T9s = T8j - T8g; + T9u = T9s - T9t; + T9S = T9t + T9s; + T9v = FNMS(KP514102744, T9u, KP857728610 * T9r); + Ta1 = FMA(KP970031253, T9S, KP242980179 * T9R); + T9H = FMA(KP857728610, T9u, KP514102744 * T9r); + T9T = FNMS(KP242980179, T9S, KP970031253 * T9R); + } + { + E T9k, T9O, T9n, T9P, T9i, T9m; + T9i = T80 - T7X; + T9k = T9i - T9j; + T9O = T9j + T9i; + T9m = T87 - T86; + T9n = T9l - T9m; + T9P = T9l + T9m; + T9o = FMA(KP514102744, T9k, KP857728610 * T9n); + Ta0 = FNMS(KP242980179, T9P, KP970031253 * T9O); + T9G = FNMS(KP514102744, T9n, KP857728610 * T9k); + T9Q = FMA(KP242980179, T9O, KP970031253 * T9P); + } + } + { + E T9h, T9w, T9F, T9I; + T9h = T99 + T9g; + T9w = T9o + T9v; + ro[WS(ros, 53)] = T9h - T9w; + ro[WS(ros, 11)] = T9h + T9w; + T9F = T9C + T9z; + T9I = T9G + T9H; + io[WS(ios, 11)] = T9F + T9I; + io[WS(ios, 53)] = T9I - T9F; + } + { + E T9D, T9E, T9J, T9K; + T9D = T9z - T9C; + T9E = T9v - T9o; + io[WS(ios, 21)] = T9D + T9E; + io[WS(ios, 43)] = T9E - T9D; + T9J = T99 - T9g; + T9K = T9H - T9G; + ro[WS(ros, 43)] = T9J - T9K; + ro[WS(ros, 21)] = T9J + T9K; + } + { + E T9N, T9U, T9Z, Ta2; + T9N = T9L + T9M; + T9U = T9Q + T9T; + ro[WS(ros, 59)] = T9N - T9U; + ro[WS(ros, 5)] = T9N + T9U; + T9Z = T9W + T9V; + Ta2 = Ta0 + Ta1; + io[WS(ios, 5)] = T9Z + Ta2; + io[WS(ios, 59)] = Ta2 - T9Z; + } + { + E T9X, T9Y, Ta3, Ta4; + T9X = T9V - T9W; + T9Y = T9T - T9Q; + io[WS(ios, 27)] = T9X + T9Y; + io[WS(ios, 37)] = T9Y - T9X; + Ta3 = T9L - T9M; + Ta4 = Ta1 - Ta0; + ro[WS(ros, 37)] = Ta3 - Ta4; + ro[WS(ros, 27)] = Ta3 + Ta4; + } + } + { + E T2z, T69, T3g, T6j, T60, T6k, T5P, T6a, T5L, T6p, T65, T6h, T4w, T6o, T64; + E T6e; + { + E T2f, T2y, T5N, T5O; + T2f = T27 + T2e; + T2y = T2o + T2x; + T2z = T2f + T2y; + T69 = T2f - T2y; + { + E T2U, T3f, T5W, T5Z; + T2U = FMA(KP098017140, T2M, KP995184726 * T2T); + T3f = FNMS(KP098017140, T3e, KP995184726 * T37); + T3g = T2U + T3f; + T6j = T3f - T2U; + T5W = T5S + T5V; + T5Z = T5X + T5Y; + T60 = T5W + T5Z; + T6k = T5Z - T5W; + } + T5N = FNMS(KP098017140, T2T, KP995184726 * T2M); + T5O = FMA(KP995184726, T3e, KP098017140 * T37); + T5P = T5N + T5O; + T6a = T5O - T5N; + { + E T5x, T6f, T5K, T6g, T5w, T5J; + T5w = T5e + T5v; + T5x = T4X + T5w; + T6f = T4X - T5w; + T5J = T5H + T5I; + T5K = T5G + T5J; + T6g = T5J - T5G; + T5L = FNMS(KP049067674, T5K, KP998795456 * T5x); + T6p = FMA(KP671558954, T6f, KP740951125 * T6g); + T65 = FMA(KP049067674, T5x, KP998795456 * T5K); + T6h = FNMS(KP671558954, T6g, KP740951125 * T6f); + } + { + E T4i, T6c, T4v, T6d, T4h, T4u; + T4h = T3Z + T4g; + T4i = T3I + T4h; + T6c = T3I - T4h; + T4u = T4s + T4t; + T4v = T4r + T4u; + T6d = T4u - T4r; + T4w = FMA(KP998795456, T4i, KP049067674 * T4v); + T6o = FNMS(KP671558954, T6c, KP740951125 * T6d); + T64 = FNMS(KP049067674, T4i, KP998795456 * T4v); + T6e = FMA(KP740951125, T6c, KP671558954 * T6d); + } + } + { + E T3h, T5M, T63, T66; + T3h = T2z + T3g; + T5M = T4w + T5L; + ro[WS(ros, 63)] = T3h - T5M; + ro[WS(ros, 1)] = T3h + T5M; + T63 = T60 + T5P; + T66 = T64 + T65; + io[WS(ios, 1)] = T63 + T66; + io[WS(ios, 63)] = T66 - T63; + } + { + E T61, T62, T67, T68; + T61 = T5P - T60; + T62 = T5L - T4w; + io[WS(ios, 31)] = T61 + T62; + io[WS(ios, 33)] = T62 - T61; + T67 = T2z - T3g; + T68 = T65 - T64; + ro[WS(ros, 33)] = T67 - T68; + ro[WS(ros, 31)] = T67 + T68; + } + { + E T6b, T6i, T6n, T6q; + T6b = T69 + T6a; + T6i = T6e + T6h; + ro[WS(ros, 49)] = T6b - T6i; + ro[WS(ros, 15)] = T6b + T6i; + T6n = T6k + T6j; + T6q = T6o + T6p; + io[WS(ios, 15)] = T6n + T6q; + io[WS(ios, 49)] = T6q - T6n; + } + { + E T6l, T6m, T6r, T6s; + T6l = T6j - T6k; + T6m = T6h - T6e; + io[WS(ios, 17)] = T6l + T6m; + io[WS(ios, 47)] = T6m - T6l; + T6r = T69 - T6a; + T6s = T6p - T6o; + ro[WS(ros, 47)] = T6r - T6s; + ro[WS(ros, 17)] = T6r + T6s; + } + } + { + E T7B, T8N, T7Q, T8X, T8E, T8Y, T8x, T8O, T8t, T93, T8J, T8V, T8a, T92, T8I; + E T8S; + { + E T7t, T7A, T8v, T8w; + T7t = T7r + T7s; + T7A = T7w + T7z; + T7B = T7t + T7A; + T8N = T7t - T7A; + { + E T7I, T7P, T8A, T8D; + T7I = FMA(KP956940335, T7E, KP290284677 * T7H); + T7P = FNMS(KP290284677, T7O, KP956940335 * T7L); + T7Q = T7I + T7P; + T8X = T7P - T7I; + T8A = T8y + T8z; + T8D = T8B + T8C; + T8E = T8A + T8D; + T8Y = T8D - T8A; + } + T8v = FNMS(KP290284677, T7E, KP956940335 * T7H); + T8w = FMA(KP290284677, T7L, KP956940335 * T7O); + T8x = T8v + T8w; + T8O = T8w - T8v; + { + E T8l, T8T, T8s, T8U, T8k, T8r; + T8k = T8g + T8j; + T8l = T8d + T8k; + T8T = T8d - T8k; + T8r = T8p + T8q; + T8s = T8o + T8r; + T8U = T8r - T8o; + T8t = FNMS(KP146730474, T8s, KP989176509 * T8l); + T93 = FMA(KP595699304, T8T, KP803207531 * T8U); + T8J = FMA(KP146730474, T8l, KP989176509 * T8s); + T8V = FNMS(KP595699304, T8U, KP803207531 * T8T); + } + { + E T82, T8Q, T89, T8R, T81, T88; + T81 = T7X + T80; + T82 = T7U + T81; + T8Q = T7U - T81; + T88 = T86 + T87; + T89 = T85 + T88; + T8R = T88 - T85; + T8a = FMA(KP989176509, T82, KP146730474 * T89); + T92 = FNMS(KP595699304, T8Q, KP803207531 * T8R); + T8I = FNMS(KP146730474, T82, KP989176509 * T89); + T8S = FMA(KP803207531, T8Q, KP595699304 * T8R); + } + } + { + E T7R, T8u, T8H, T8K; + T7R = T7B + T7Q; + T8u = T8a + T8t; + ro[WS(ros, 61)] = T7R - T8u; + ro[WS(ros, 3)] = T7R + T8u; + T8H = T8E + T8x; + T8K = T8I + T8J; + io[WS(ios, 3)] = T8H + T8K; + io[WS(ios, 61)] = T8K - T8H; + } + { + E T8F, T8G, T8L, T8M; + T8F = T8x - T8E; + T8G = T8t - T8a; + io[WS(ios, 29)] = T8F + T8G; + io[WS(ios, 35)] = T8G - T8F; + T8L = T7B - T7Q; + T8M = T8J - T8I; + ro[WS(ros, 35)] = T8L - T8M; + ro[WS(ros, 29)] = T8L + T8M; + } + { + E T8P, T8W, T91, T94; + T8P = T8N + T8O; + T8W = T8S + T8V; + ro[WS(ros, 51)] = T8P - T8W; + ro[WS(ros, 13)] = T8P + T8W; + T91 = T8Y + T8X; + T94 = T92 + T93; + io[WS(ios, 13)] = T91 + T94; + io[WS(ios, 51)] = T94 - T91; + } + { + E T8Z, T90, T95, T96; + T8Z = T8X - T8Y; + T90 = T8V - T8S; + io[WS(ios, 19)] = T8Z + T90; + io[WS(ios, 45)] = T90 - T8Z; + T95 = T8N - T8O; + T96 = T93 - T92; + ro[WS(ros, 45)] = T95 - T96; + ro[WS(ros, 19)] = T95 + T96; + } + } + } +} + +static void mr2hc_128(const R *I, R *ro, R *io, stride is, stride ros, stride ios, int v, int ivs, int ovs) +{ + int i; + for (i = v; i > 0; --i) { + mr2hc_128_0(I, ro, io, is, ros, ios); + I += ivs; + ro += ovs; + io += ovs; + } +} + +static const kr2hc_desc desc = { 128, "mr2hc_128", {812, 186, 144, 0}, &GENUS, 0, 0, 0, 0, 0 }; + +void X(codelet_mr2hc_128) (planner *p) { + X(kr2hc_register) (p, mr2hc_128, &desc); +} diff --git a/src/fftw3/rdft/codelets/r2hc/mr2hc_32.c b/src/fftw3/rdft/codelets/r2hc/mr2hc_32.c new file mode 100644 index 0000000..4f351a4 --- /dev/null +++ b/src/fftw3/rdft/codelets/r2hc/mr2hc_32.c @@ -0,0 +1,330 @@ +/* + * 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 21:56:45 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_r2hc_noinline -compact -variables 4 -n 32 -name mr2hc_32 -include r2hc.h */ + +/* + * This function contains 156 FP additions, 42 FP multiplications, + * (or, 140 additions, 26 multiplications, 16 fused multiply/add), + * 53 stack variables, and 64 memory accesses + */ +/* + * Generator Id's : + * $Id: mr2hc_32.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: mr2hc_32.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: mr2hc_32.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + */ + +#include "r2hc.h" + +static void mr2hc_32_0(const R *I, R *ro, R *io, stride is, stride ros, stride ios) +{ + 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); + { + E T7, T2b, Tv, T1l, Te, T2o, Ty, T1k, Tt, T2d, TF, T1h, Tm, T2c, TC; + E T1i, T1Z, T22, T2k, T2j, T1e, T1C, T19, T1B, T1S, T1V, T2h, T2g, TX, T1z; + E TS, T1y; + { + E T1, T2, T3, T4, T5, T6; + T1 = I[0]; + T2 = I[WS(is, 16)]; + T3 = T1 + T2; + T4 = I[WS(is, 8)]; + T5 = I[WS(is, 24)]; + T6 = T4 + T5; + T7 = T3 + T6; + T2b = T3 - T6; + Tv = T1 - T2; + T1l = T4 - T5; + } + { + E Ta, Tw, Td, Tx; + { + E T8, T9, Tb, Tc; + T8 = I[WS(is, 4)]; + T9 = I[WS(is, 20)]; + Ta = T8 + T9; + Tw = T8 - T9; + Tb = I[WS(is, 28)]; + Tc = I[WS(is, 12)]; + Td = Tb + Tc; + Tx = Tb - Tc; + } + Te = Ta + Td; + T2o = Td - Ta; + Ty = KP707106781 * (Tw + Tx); + T1k = KP707106781 * (Tx - Tw); + } + { + E Tp, TD, Ts, TE; + { + E Tn, To, Tq, Tr; + Tn = I[WS(is, 30)]; + To = I[WS(is, 14)]; + Tp = Tn + To; + TD = Tn - To; + Tq = I[WS(is, 6)]; + Tr = I[WS(is, 22)]; + Ts = Tq + Tr; + TE = Tq - Tr; + } + Tt = Tp + Ts; + T2d = Tp - Ts; + TF = FMA(KP923879532, TD, KP382683432 * TE); + T1h = FNMS(KP923879532, TE, KP382683432 * TD); + } + { + E Ti, TA, Tl, TB; + { + E Tg, Th, Tj, Tk; + Tg = I[WS(is, 2)]; + Th = I[WS(is, 18)]; + Ti = Tg + Th; + TA = Tg - Th; + Tj = I[WS(is, 10)]; + Tk = I[WS(is, 26)]; + Tl = Tj + Tk; + TB = Tj - Tk; + } + Tm = Ti + Tl; + T2c = Ti - Tl; + TC = FNMS(KP382683432, TB, KP923879532 * TA); + T1i = FMA(KP382683432, TA, KP923879532 * TB); + } + { + E T11, T1X, T1d, T1Y, T14, T20, T17, T21, T1a, T18; + { + E TZ, T10, T1b, T1c; + TZ = I[WS(is, 31)]; + T10 = I[WS(is, 15)]; + T11 = TZ - T10; + T1X = TZ + T10; + T1b = I[WS(is, 7)]; + T1c = I[WS(is, 23)]; + T1d = T1b - T1c; + T1Y = T1b + T1c; + } + { + E T12, T13, T15, T16; + T12 = I[WS(is, 3)]; + T13 = I[WS(is, 19)]; + T14 = T12 - T13; + T20 = T12 + T13; + T15 = I[WS(is, 27)]; + T16 = I[WS(is, 11)]; + T17 = T15 - T16; + T21 = T15 + T16; + } + T1Z = T1X + T1Y; + T22 = T20 + T21; + T2k = T21 - T20; + T2j = T1X - T1Y; + T1a = KP707106781 * (T17 - T14); + T1e = T1a - T1d; + T1C = T1d + T1a; + T18 = KP707106781 * (T14 + T17); + T19 = T11 + T18; + T1B = T11 - T18; + } + { + E TK, T1Q, TW, T1R, TN, T1T, TQ, T1U, TT, TR; + { + E TI, TJ, TU, TV; + TI = I[WS(is, 1)]; + TJ = I[WS(is, 17)]; + TK = TI - TJ; + T1Q = TI + TJ; + TU = I[WS(is, 9)]; + TV = I[WS(is, 25)]; + TW = TU - TV; + T1R = TU + TV; + } + { + E TL, TM, TO, TP; + TL = I[WS(is, 5)]; + TM = I[WS(is, 21)]; + TN = TL - TM; + T1T = TL + TM; + TO = I[WS(is, 29)]; + TP = I[WS(is, 13)]; + TQ = TO - TP; + T1U = TO + TP; + } + T1S = T1Q + T1R; + T1V = T1T + T1U; + T2h = T1U - T1T; + T2g = T1Q - T1R; + TT = KP707106781 * (TQ - TN); + TX = TT - TW; + T1z = TW + TT; + TR = KP707106781 * (TN + TQ); + TS = TK + TR; + T1y = TK - TR; + } + { + E Tf, Tu, T27, T28, T29, T2a; + Tf = T7 + Te; + Tu = Tm + Tt; + T27 = Tf + Tu; + T28 = T1S + T1V; + T29 = T1Z + T22; + T2a = T28 + T29; + ro[WS(ros, 8)] = Tf - Tu; + io[WS(ios, 8)] = T29 - T28; + ro[WS(ros, 16)] = T27 - T2a; + ro[0] = T27 + T2a; + } + { + E T1P, T25, T24, T26, T1W, T23; + T1P = T7 - Te; + T25 = Tt - Tm; + T1W = T1S - T1V; + T23 = T1Z - T22; + T24 = KP707106781 * (T1W + T23); + T26 = KP707106781 * (T23 - T1W); + ro[WS(ros, 12)] = T1P - T24; + io[WS(ios, 12)] = T26 - T25; + ro[WS(ros, 4)] = T1P + T24; + io[WS(ios, 4)] = T25 + T26; + } + { + E T2f, T2v, T2p, T2r, T2m, T2q, T2u, T2w, T2e, T2n; + T2e = KP707106781 * (T2c + T2d); + T2f = T2b + T2e; + T2v = T2b - T2e; + T2n = KP707106781 * (T2d - T2c); + T2p = T2n - T2o; + T2r = T2o + T2n; + { + E T2i, T2l, T2s, T2t; + T2i = FMA(KP923879532, T2g, KP382683432 * T2h); + T2l = FNMS(KP382683432, T2k, KP923879532 * T2j); + T2m = T2i + T2l; + T2q = T2l - T2i; + T2s = FNMS(KP382683432, T2g, KP923879532 * T2h); + T2t = FMA(KP382683432, T2j, KP923879532 * T2k); + T2u = T2s + T2t; + T2w = T2t - T2s; + } + ro[WS(ros, 14)] = T2f - T2m; + io[WS(ios, 14)] = T2u - T2r; + ro[WS(ros, 2)] = T2f + T2m; + io[WS(ios, 2)] = T2r + T2u; + io[WS(ios, 6)] = T2p + T2q; + ro[WS(ros, 6)] = T2v + T2w; + io[WS(ios, 10)] = T2q - T2p; + ro[WS(ros, 10)] = T2v - T2w; + } + { + E TH, T1t, T1s, T1u, T1g, T1o, T1n, T1p; + { + E Tz, TG, T1q, T1r; + Tz = Tv + Ty; + TG = TC + TF; + TH = Tz + TG; + T1t = Tz - TG; + T1q = FNMS(KP195090322, TS, KP980785280 * TX); + T1r = FMA(KP195090322, T19, KP980785280 * T1e); + T1s = T1q + T1r; + T1u = T1r - T1q; + } + { + E TY, T1f, T1j, T1m; + TY = FMA(KP980785280, TS, KP195090322 * TX); + T1f = FNMS(KP195090322, T1e, KP980785280 * T19); + T1g = TY + T1f; + T1o = T1f - TY; + T1j = T1h - T1i; + T1m = T1k - T1l; + T1n = T1j - T1m; + T1p = T1m + T1j; + } + ro[WS(ros, 15)] = TH - T1g; + io[WS(ios, 15)] = T1s - T1p; + ro[WS(ros, 1)] = TH + T1g; + io[WS(ios, 1)] = T1p + T1s; + io[WS(ios, 7)] = T1n + T1o; + ro[WS(ros, 7)] = T1t + T1u; + io[WS(ios, 9)] = T1o - T1n; + ro[WS(ros, 9)] = T1t - T1u; + } + { + E T1x, T1N, T1M, T1O, T1E, T1I, T1H, T1J; + { + E T1v, T1w, T1K, T1L; + T1v = Tv - Ty; + T1w = T1i + T1h; + T1x = T1v + T1w; + T1N = T1v - T1w; + T1K = FNMS(KP555570233, T1y, KP831469612 * T1z); + T1L = FMA(KP555570233, T1B, KP831469612 * T1C); + T1M = T1K + T1L; + T1O = T1L - T1K; + } + { + E T1A, T1D, T1F, T1G; + T1A = FMA(KP831469612, T1y, KP555570233 * T1z); + T1D = FNMS(KP555570233, T1C, KP831469612 * T1B); + T1E = T1A + T1D; + T1I = T1D - T1A; + T1F = TF - TC; + T1G = T1l + T1k; + T1H = T1F - T1G; + T1J = T1G + T1F; + } + ro[WS(ros, 13)] = T1x - T1E; + io[WS(ios, 13)] = T1M - T1J; + ro[WS(ros, 3)] = T1x + T1E; + io[WS(ios, 3)] = T1J + T1M; + io[WS(ios, 5)] = T1H + T1I; + ro[WS(ros, 5)] = T1N + T1O; + io[WS(ios, 11)] = T1I - T1H; + ro[WS(ros, 11)] = T1N - T1O; + } + } +} + +static void mr2hc_32(const R *I, R *ro, R *io, stride is, stride ros, stride ios, int v, int ivs, int ovs) +{ + int i; + for (i = v; i > 0; --i) { + mr2hc_32_0(I, ro, io, is, ros, ios); + I += ivs; + ro += ovs; + io += ovs; + } +} + +static const kr2hc_desc desc = { 32, "mr2hc_32", {140, 26, 16, 0}, &GENUS, 0, 0, 0, 0, 0 }; + +void X(codelet_mr2hc_32) (planner *p) { + X(kr2hc_register) (p, mr2hc_32, &desc); +} diff --git a/src/fftw3/rdft/codelets/r2hc/mr2hc_64.c b/src/fftw3/rdft/codelets/r2hc/mr2hc_64.c new file mode 100644 index 0000000..c859fbf --- /dev/null +++ b/src/fftw3/rdft/codelets/r2hc/mr2hc_64.c @@ -0,0 +1,729 @@ +/* + * 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 21:56:49 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_r2hc_noinline -compact -variables 4 -n 64 -name mr2hc_64 -include r2hc.h */ + +/* + * This function contains 394 FP additions, 124 FP multiplications, + * (or, 342 additions, 72 multiplications, 52 fused multiply/add), + * 105 stack variables, and 128 memory accesses + */ +/* + * Generator Id's : + * $Id: mr2hc_64.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: mr2hc_64.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: mr2hc_64.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + */ + +#include "r2hc.h" + +static void mr2hc_64_0(const R *I, R *ro, R *io, stride is, stride ros, stride ios) +{ + DK(KP773010453, +0.773010453362736960810906609758469800971041293); + DK(KP634393284, +0.634393284163645498215171613225493370675687095); + DK(KP098017140, +0.098017140329560601994195563888641845861136673); + DK(KP995184726, +0.995184726672196886244836953109479921575474869); + DK(KP290284677, +0.290284677254462367636192375817395274691476278); + DK(KP956940335, +0.956940335732208864935797886980269969482849206); + DK(KP471396736, +0.471396736825997648556387625905254377657460319); + DK(KP881921264, +0.881921264348355029712756863660388349508442621); + 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); + { + E T4l, T5a, T15, T3n, T2T, T3Q, T7, Te, Tf, T4A, T4L, T1X, T3B, T23, T3y; + E T5I, T66, T4R, T52, T2j, T3F, T2H, T3I, T5P, T69, T1i, T3t, T1l, T3u, TZ; + E T63, T4v, T58, T1r, T3r, T1u, T3q, TK, T62, T4s, T57, Tm, Tt, Tu, T4o; + E T5b, T1c, T3R, T2Q, T3o, T1M, T3z, T5L, T67, T26, T3C, T4H, T4M, T2y, T3J; + E T5S, T6a, T2C, T3G, T4Y, T53; + { + E T3, T11, Td, T13, T6, T2S, Ta, T12, T14, T2R; + { + E T1, T2, Tb, Tc; + T1 = I[0]; + T2 = I[WS(is, 32)]; + T3 = T1 + T2; + T11 = T1 - T2; + Tb = I[WS(is, 56)]; + Tc = I[WS(is, 24)]; + Td = Tb + Tc; + T13 = Tb - Tc; + } + { + E T4, T5, T8, T9; + T4 = I[WS(is, 16)]; + T5 = I[WS(is, 48)]; + T6 = T4 + T5; + T2S = T4 - T5; + T8 = I[WS(is, 8)]; + T9 = I[WS(is, 40)]; + Ta = T8 + T9; + T12 = T8 - T9; + } + T4l = T3 - T6; + T5a = Td - Ta; + T14 = KP707106781 * (T12 + T13); + T15 = T11 + T14; + T3n = T11 - T14; + T2R = KP707106781 * (T13 - T12); + T2T = T2R - T2S; + T3Q = T2S + T2R; + T7 = T3 + T6; + Te = Ta + Td; + Tf = T7 + Te; + } + { + E T1P, T4J, T21, T4y, T1S, T4K, T1W, T4z; + { + E T1N, T1O, T1Z, T20; + T1N = I[WS(is, 57)]; + T1O = I[WS(is, 25)]; + T1P = T1N - T1O; + T4J = T1N + T1O; + T1Z = I[WS(is, 1)]; + T20 = I[WS(is, 33)]; + T21 = T1Z - T20; + T4y = T1Z + T20; + } + { + E T1Q, T1R, T1U, T1V; + T1Q = I[WS(is, 9)]; + T1R = I[WS(is, 41)]; + T1S = T1Q - T1R; + T4K = T1Q + T1R; + T1U = I[WS(is, 17)]; + T1V = I[WS(is, 49)]; + T1W = T1U - T1V; + T4z = T1U + T1V; + } + T4A = T4y - T4z; + T4L = T4J - T4K; + { + E T1T, T22, T5G, T5H; + T1T = KP707106781 * (T1P - T1S); + T1X = T1T - T1W; + T3B = T1W + T1T; + T22 = KP707106781 * (T1S + T1P); + T23 = T21 + T22; + T3y = T21 - T22; + T5G = T4y + T4z; + T5H = T4K + T4J; + T5I = T5G + T5H; + T66 = T5G - T5H; + } + } + { + E T2b, T4P, T2G, T4Q, T2e, T51, T2h, T50; + { + E T29, T2a, T2E, T2F; + T29 = I[WS(is, 63)]; + T2a = I[WS(is, 31)]; + T2b = T29 - T2a; + T4P = T29 + T2a; + T2E = I[WS(is, 15)]; + T2F = I[WS(is, 47)]; + T2G = T2E - T2F; + T4Q = T2E + T2F; + } + { + E T2c, T2d, T2f, T2g; + T2c = I[WS(is, 7)]; + T2d = I[WS(is, 39)]; + T2e = T2c - T2d; + T51 = T2c + T2d; + T2f = I[WS(is, 55)]; + T2g = I[WS(is, 23)]; + T2h = T2f - T2g; + T50 = T2f + T2g; + } + T4R = T4P - T4Q; + T52 = T50 - T51; + { + E T2i, T2D, T5N, T5O; + T2i = KP707106781 * (T2e + T2h); + T2j = T2b + T2i; + T3F = T2b - T2i; + T2D = KP707106781 * (T2h - T2e); + T2H = T2D - T2G; + T3I = T2G + T2D; + T5N = T4P + T4Q; + T5O = T51 + T50; + T5P = T5N + T5O; + T69 = T5N - T5O; + } + } + { + E TN, T1e, TX, T1g, TQ, T1k, TU, T1f, T1h, T1j; + { + E TL, TM, TV, TW; + TL = I[WS(is, 62)]; + TM = I[WS(is, 30)]; + TN = TL + TM; + T1e = TL - TM; + TV = I[WS(is, 54)]; + TW = I[WS(is, 22)]; + TX = TV + TW; + T1g = TV - TW; + } + { + E TO, TP, TS, TT; + TO = I[WS(is, 14)]; + TP = I[WS(is, 46)]; + TQ = TO + TP; + T1k = TO - TP; + TS = I[WS(is, 6)]; + TT = I[WS(is, 38)]; + TU = TS + TT; + T1f = TS - TT; + } + T1h = KP707106781 * (T1f + T1g); + T1i = T1e + T1h; + T3t = T1e - T1h; + T1j = KP707106781 * (T1g - T1f); + T1l = T1j - T1k; + T3u = T1k + T1j; + { + E TR, TY, T4t, T4u; + TR = TN + TQ; + TY = TU + TX; + TZ = TR + TY; + T63 = TR - TY; + T4t = TN - TQ; + T4u = TX - TU; + T4v = FNMS(KP382683432, T4u, KP923879532 * T4t); + T58 = FMA(KP382683432, T4t, KP923879532 * T4u); + } + } + { + E Ty, T1s, TI, T1n, TB, T1q, TF, T1o, T1p, T1t; + { + E Tw, Tx, TG, TH; + Tw = I[WS(is, 2)]; + Tx = I[WS(is, 34)]; + Ty = Tw + Tx; + T1s = Tw - Tx; + TG = I[WS(is, 58)]; + TH = I[WS(is, 26)]; + TI = TG + TH; + T1n = TG - TH; + } + { + E Tz, TA, TD, TE; + Tz = I[WS(is, 18)]; + TA = I[WS(is, 50)]; + TB = Tz + TA; + T1q = Tz - TA; + TD = I[WS(is, 10)]; + TE = I[WS(is, 42)]; + TF = TD + TE; + T1o = TD - TE; + } + T1p = KP707106781 * (T1n - T1o); + T1r = T1p - T1q; + T3r = T1q + T1p; + T1t = KP707106781 * (T1o + T1n); + T1u = T1s + T1t; + T3q = T1s - T1t; + { + E TC, TJ, T4q, T4r; + TC = Ty + TB; + TJ = TF + TI; + TK = TC + TJ; + T62 = TC - TJ; + T4q = Ty - TB; + T4r = TI - TF; + T4s = FMA(KP923879532, T4q, KP382683432 * T4r); + T57 = FNMS(KP382683432, T4q, KP923879532 * T4r); + } + } + { + E Ti, T16, Ts, T1a, Tl, T17, Tp, T19, T4m, T4n; + { + E Tg, Th, Tq, Tr; + Tg = I[WS(is, 4)]; + Th = I[WS(is, 36)]; + Ti = Tg + Th; + T16 = Tg - Th; + Tq = I[WS(is, 12)]; + Tr = I[WS(is, 44)]; + Ts = Tq + Tr; + T1a = Tq - Tr; + } + { + E Tj, Tk, Tn, To; + Tj = I[WS(is, 20)]; + Tk = I[WS(is, 52)]; + Tl = Tj + Tk; + T17 = Tj - Tk; + Tn = I[WS(is, 60)]; + To = I[WS(is, 28)]; + Tp = Tn + To; + T19 = Tn - To; + } + Tm = Ti + Tl; + Tt = Tp + Ts; + Tu = Tm + Tt; + T4m = Ti - Tl; + T4n = Tp - Ts; + T4o = KP707106781 * (T4m + T4n); + T5b = KP707106781 * (T4n - T4m); + { + E T18, T1b, T2O, T2P; + T18 = FNMS(KP382683432, T17, KP923879532 * T16); + T1b = FMA(KP923879532, T19, KP382683432 * T1a); + T1c = T18 + T1b; + T3R = T1b - T18; + T2O = FNMS(KP923879532, T1a, KP382683432 * T19); + T2P = FMA(KP382683432, T16, KP923879532 * T17); + T2Q = T2O - T2P; + T3o = T2P + T2O; + } + } + { + E T1A, T4E, T1K, T4C, T1D, T4F, T1H, T4B; + { + E T1y, T1z, T1I, T1J; + T1y = I[WS(is, 61)]; + T1z = I[WS(is, 29)]; + T1A = T1y - T1z; + T4E = T1y + T1z; + T1I = I[WS(is, 21)]; + T1J = I[WS(is, 53)]; + T1K = T1I - T1J; + T4C = T1I + T1J; + } + { + E T1B, T1C, T1F, T1G; + T1B = I[WS(is, 13)]; + T1C = I[WS(is, 45)]; + T1D = T1B - T1C; + T4F = T1B + T1C; + T1F = I[WS(is, 5)]; + T1G = I[WS(is, 37)]; + T1H = T1F - T1G; + T4B = T1F + T1G; + } + { + E T1E, T1L, T5J, T5K; + T1E = FNMS(KP923879532, T1D, KP382683432 * T1A); + T1L = FMA(KP382683432, T1H, KP923879532 * T1K); + T1M = T1E - T1L; + T3z = T1L + T1E; + T5J = T4B + T4C; + T5K = T4E + T4F; + T5L = T5J + T5K; + T67 = T5K - T5J; + } + { + E T24, T25, T4D, T4G; + T24 = FNMS(KP382683432, T1K, KP923879532 * T1H); + T25 = FMA(KP923879532, T1A, KP382683432 * T1D); + T26 = T24 + T25; + T3C = T25 - T24; + T4D = T4B - T4C; + T4G = T4E - T4F; + T4H = KP707106781 * (T4D + T4G); + T4M = KP707106781 * (T4G - T4D); + } + } + { + E T2m, T4S, T2w, T4W, T2p, T4T, T2t, T4V; + { + E T2k, T2l, T2u, T2v; + T2k = I[WS(is, 3)]; + T2l = I[WS(is, 35)]; + T2m = T2k - T2l; + T4S = T2k + T2l; + T2u = I[WS(is, 11)]; + T2v = I[WS(is, 43)]; + T2w = T2u - T2v; + T4W = T2u + T2v; + } + { + E T2n, T2o, T2r, T2s; + T2n = I[WS(is, 19)]; + T2o = I[WS(is, 51)]; + T2p = T2n - T2o; + T4T = T2n + T2o; + T2r = I[WS(is, 59)]; + T2s = I[WS(is, 27)]; + T2t = T2r - T2s; + T4V = T2r + T2s; + } + { + E T2q, T2x, T5Q, T5R; + T2q = FNMS(KP382683432, T2p, KP923879532 * T2m); + T2x = FMA(KP923879532, T2t, KP382683432 * T2w); + T2y = T2q + T2x; + T3J = T2x - T2q; + T5Q = T4S + T4T; + T5R = T4V + T4W; + T5S = T5Q + T5R; + T6a = T5R - T5Q; + } + { + E T2A, T2B, T4U, T4X; + T2A = FNMS(KP923879532, T2w, KP382683432 * T2t); + T2B = FMA(KP382683432, T2m, KP923879532 * T2p); + T2C = T2A - T2B; + T3G = T2B + T2A; + T4U = T4S - T4T; + T4X = T4V - T4W; + T4Y = KP707106781 * (T4U + T4X); + T53 = KP707106781 * (T4X - T4U); + } + } + { + E Tv, T10, T5X, T5Y, T5Z, T60; + Tv = Tf + Tu; + T10 = TK + TZ; + T5X = Tv + T10; + T5Y = T5I + T5L; + T5Z = T5P + T5S; + T60 = T5Y + T5Z; + ro[WS(ros, 16)] = Tv - T10; + io[WS(ios, 16)] = T5Z - T5Y; + ro[WS(ros, 32)] = T5X - T60; + ro[0] = T5X + T60; + } + { + E T5F, T5V, T5U, T5W, T5M, T5T; + T5F = Tf - Tu; + T5V = TZ - TK; + T5M = T5I - T5L; + T5T = T5P - T5S; + T5U = KP707106781 * (T5M + T5T); + T5W = KP707106781 * (T5T - T5M); + ro[WS(ros, 24)] = T5F - T5U; + io[WS(ios, 24)] = T5W - T5V; + ro[WS(ros, 8)] = T5F + T5U; + io[WS(ios, 8)] = T5V + T5W; + } + { + E T65, T6l, T6k, T6m, T6c, T6g, T6f, T6h; + { + E T61, T64, T6i, T6j; + T61 = T7 - Te; + T64 = KP707106781 * (T62 + T63); + T65 = T61 + T64; + T6l = T61 - T64; + T6i = FNMS(KP382683432, T66, KP923879532 * T67); + T6j = FMA(KP382683432, T69, KP923879532 * T6a); + T6k = T6i + T6j; + T6m = T6j - T6i; + } + { + E T68, T6b, T6d, T6e; + T68 = FMA(KP923879532, T66, KP382683432 * T67); + T6b = FNMS(KP382683432, T6a, KP923879532 * T69); + T6c = T68 + T6b; + T6g = T6b - T68; + T6d = KP707106781 * (T63 - T62); + T6e = Tt - Tm; + T6f = T6d - T6e; + T6h = T6e + T6d; + } + ro[WS(ros, 28)] = T65 - T6c; + io[WS(ios, 28)] = T6k - T6h; + ro[WS(ros, 4)] = T65 + T6c; + io[WS(ios, 4)] = T6h + T6k; + io[WS(ios, 12)] = T6f + T6g; + ro[WS(ros, 12)] = T6l + T6m; + io[WS(ios, 20)] = T6g - T6f; + ro[WS(ros, 20)] = T6l - T6m; + } + { + E T5n, T5D, T5x, T5z, T5q, T5A, T5t, T5B; + { + E T5l, T5m, T5v, T5w; + T5l = T4l - T4o; + T5m = T58 - T57; + T5n = T5l + T5m; + T5D = T5l - T5m; + T5v = T4v - T4s; + T5w = T5b - T5a; + T5x = T5v - T5w; + T5z = T5w + T5v; + } + { + E T5o, T5p, T5r, T5s; + T5o = T4A - T4H; + T5p = T4M - T4L; + T5q = FMA(KP831469612, T5o, KP555570233 * T5p); + T5A = FNMS(KP555570233, T5o, KP831469612 * T5p); + T5r = T4R - T4Y; + T5s = T53 - T52; + T5t = FNMS(KP555570233, T5s, KP831469612 * T5r); + T5B = FMA(KP555570233, T5r, KP831469612 * T5s); + } + { + E T5u, T5C, T5y, T5E; + T5u = T5q + T5t; + ro[WS(ros, 26)] = T5n - T5u; + ro[WS(ros, 6)] = T5n + T5u; + T5C = T5A + T5B; + io[WS(ios, 6)] = T5z + T5C; + io[WS(ios, 26)] = T5C - T5z; + T5y = T5t - T5q; + io[WS(ios, 10)] = T5x + T5y; + io[WS(ios, 22)] = T5y - T5x; + T5E = T5B - T5A; + ro[WS(ros, 22)] = T5D - T5E; + ro[WS(ros, 10)] = T5D + T5E; + } + } + { + E T4x, T5j, T5d, T5f, T4O, T5g, T55, T5h; + { + E T4p, T4w, T59, T5c; + T4p = T4l + T4o; + T4w = T4s + T4v; + T4x = T4p + T4w; + T5j = T4p - T4w; + T59 = T57 + T58; + T5c = T5a + T5b; + T5d = T59 - T5c; + T5f = T5c + T59; + } + { + E T4I, T4N, T4Z, T54; + T4I = T4A + T4H; + T4N = T4L + T4M; + T4O = FMA(KP980785280, T4I, KP195090322 * T4N); + T5g = FNMS(KP195090322, T4I, KP980785280 * T4N); + T4Z = T4R + T4Y; + T54 = T52 + T53; + T55 = FNMS(KP195090322, T54, KP980785280 * T4Z); + T5h = FMA(KP195090322, T4Z, KP980785280 * T54); + } + { + E T56, T5i, T5e, T5k; + T56 = T4O + T55; + ro[WS(ros, 30)] = T4x - T56; + ro[WS(ros, 2)] = T4x + T56; + T5i = T5g + T5h; + io[WS(ios, 2)] = T5f + T5i; + io[WS(ios, 30)] = T5i - T5f; + T5e = T55 - T4O; + io[WS(ios, 14)] = T5d + T5e; + io[WS(ios, 18)] = T5e - T5d; + T5k = T5h - T5g; + ro[WS(ros, 18)] = T5j - T5k; + ro[WS(ros, 14)] = T5j + T5k; + } + } + { + E T3p, T41, T4c, T3S, T3w, T4b, T49, T4h, T3P, T42, T3E, T3W, T46, T4g, T3L; + E T3X; + { + E T3s, T3v, T3A, T3D; + T3p = T3n + T3o; + T41 = T3n - T3o; + T4c = T3R - T3Q; + T3S = T3Q + T3R; + T3s = FMA(KP831469612, T3q, KP555570233 * T3r); + T3v = FNMS(KP555570233, T3u, KP831469612 * T3t); + T3w = T3s + T3v; + T4b = T3v - T3s; + { + E T47, T48, T3N, T3O; + T47 = T3F - T3G; + T48 = T3J - T3I; + T49 = FNMS(KP471396736, T48, KP881921264 * T47); + T4h = FMA(KP471396736, T47, KP881921264 * T48); + T3N = FNMS(KP555570233, T3q, KP831469612 * T3r); + T3O = FMA(KP555570233, T3t, KP831469612 * T3u); + T3P = T3N + T3O; + T42 = T3O - T3N; + } + T3A = T3y + T3z; + T3D = T3B + T3C; + T3E = FMA(KP956940335, T3A, KP290284677 * T3D); + T3W = FNMS(KP290284677, T3A, KP956940335 * T3D); + { + E T44, T45, T3H, T3K; + T44 = T3y - T3z; + T45 = T3C - T3B; + T46 = FMA(KP881921264, T44, KP471396736 * T45); + T4g = FNMS(KP471396736, T44, KP881921264 * T45); + T3H = T3F + T3G; + T3K = T3I + T3J; + T3L = FNMS(KP290284677, T3K, KP956940335 * T3H); + T3X = FMA(KP290284677, T3H, KP956940335 * T3K); + } + } + { + E T3x, T3M, T3V, T3Y; + T3x = T3p + T3w; + T3M = T3E + T3L; + ro[WS(ros, 29)] = T3x - T3M; + ro[WS(ros, 3)] = T3x + T3M; + T3V = T3S + T3P; + T3Y = T3W + T3X; + io[WS(ios, 3)] = T3V + T3Y; + io[WS(ios, 29)] = T3Y - T3V; + } + { + E T3T, T3U, T3Z, T40; + T3T = T3P - T3S; + T3U = T3L - T3E; + io[WS(ios, 13)] = T3T + T3U; + io[WS(ios, 19)] = T3U - T3T; + T3Z = T3p - T3w; + T40 = T3X - T3W; + ro[WS(ros, 19)] = T3Z - T40; + ro[WS(ros, 13)] = T3Z + T40; + } + { + E T43, T4a, T4f, T4i; + T43 = T41 + T42; + T4a = T46 + T49; + ro[WS(ros, 27)] = T43 - T4a; + ro[WS(ros, 5)] = T43 + T4a; + T4f = T4c + T4b; + T4i = T4g + T4h; + io[WS(ios, 5)] = T4f + T4i; + io[WS(ios, 27)] = T4i - T4f; + } + { + E T4d, T4e, T4j, T4k; + T4d = T4b - T4c; + T4e = T49 - T46; + io[WS(ios, 11)] = T4d + T4e; + io[WS(ios, 21)] = T4e - T4d; + T4j = T41 - T42; + T4k = T4h - T4g; + ro[WS(ros, 21)] = T4j - T4k; + ro[WS(ros, 11)] = T4j + T4k; + } + } + { + E T1d, T33, T3e, T2U, T1w, T3d, T3b, T3j, T2N, T34, T28, T2Y, T38, T3i, T2J; + E T2Z; + { + E T1m, T1v, T1Y, T27; + T1d = T15 - T1c; + T33 = T15 + T1c; + T3e = T2T + T2Q; + T2U = T2Q - T2T; + T1m = FMA(KP195090322, T1i, KP980785280 * T1l); + T1v = FNMS(KP195090322, T1u, KP980785280 * T1r); + T1w = T1m - T1v; + T3d = T1v + T1m; + { + E T39, T3a, T2L, T2M; + T39 = T2j + T2y; + T3a = T2H + T2C; + T3b = FNMS(KP098017140, T3a, KP995184726 * T39); + T3j = FMA(KP995184726, T3a, KP098017140 * T39); + T2L = FNMS(KP195090322, T1l, KP980785280 * T1i); + T2M = FMA(KP980785280, T1u, KP195090322 * T1r); + T2N = T2L - T2M; + T34 = T2M + T2L; + } + T1Y = T1M - T1X; + T27 = T23 - T26; + T28 = FMA(KP634393284, T1Y, KP773010453 * T27); + T2Y = FNMS(KP634393284, T27, KP773010453 * T1Y); + { + E T36, T37, T2z, T2I; + T36 = T1X + T1M; + T37 = T23 + T26; + T38 = FMA(KP098017140, T36, KP995184726 * T37); + T3i = FNMS(KP098017140, T37, KP995184726 * T36); + T2z = T2j - T2y; + T2I = T2C - T2H; + T2J = FNMS(KP634393284, T2I, KP773010453 * T2z); + T2Z = FMA(KP773010453, T2I, KP634393284 * T2z); + } + } + { + E T1x, T2K, T2X, T30; + T1x = T1d + T1w; + T2K = T28 + T2J; + ro[WS(ros, 25)] = T1x - T2K; + ro[WS(ros, 7)] = T1x + T2K; + T2X = T2U + T2N; + T30 = T2Y + T2Z; + io[WS(ios, 7)] = T2X + T30; + io[WS(ios, 25)] = T30 - T2X; + } + { + E T2V, T2W, T31, T32; + T2V = T2N - T2U; + T2W = T2J - T28; + io[WS(ios, 9)] = T2V + T2W; + io[WS(ios, 23)] = T2W - T2V; + T31 = T1d - T1w; + T32 = T2Z - T2Y; + ro[WS(ros, 23)] = T31 - T32; + ro[WS(ros, 9)] = T31 + T32; + } + { + E T35, T3c, T3h, T3k; + T35 = T33 + T34; + T3c = T38 + T3b; + ro[WS(ros, 31)] = T35 - T3c; + ro[WS(ros, 1)] = T35 + T3c; + T3h = T3e + T3d; + T3k = T3i + T3j; + io[WS(ios, 1)] = T3h + T3k; + io[WS(ios, 31)] = T3k - T3h; + } + { + E T3f, T3g, T3l, T3m; + T3f = T3d - T3e; + T3g = T3b - T38; + io[WS(ios, 15)] = T3f + T3g; + io[WS(ios, 17)] = T3g - T3f; + T3l = T33 - T34; + T3m = T3j - T3i; + ro[WS(ros, 17)] = T3l - T3m; + ro[WS(ros, 15)] = T3l + T3m; + } + } + } +} + +static void mr2hc_64(const R *I, R *ro, R *io, stride is, stride ros, stride ios, int v, int ivs, int ovs) +{ + int i; + for (i = v; i > 0; --i) { + mr2hc_64_0(I, ro, io, is, ros, ios); + I += ivs; + ro += ovs; + io += ovs; + } +} + +static const kr2hc_desc desc = { 64, "mr2hc_64", {342, 72, 52, 0}, &GENUS, 0, 0, 0, 0, 0 }; + +void X(codelet_mr2hc_64) (planner *p) { + X(kr2hc_register) (p, mr2hc_64, &desc); +} diff --git a/src/fftw3/rdft/codelets/r2hc/r2hcII_10.c b/src/fftw3/rdft/codelets/r2hc/r2hcII_10.c new file mode 100644 index 0000000..d163e75 --- /dev/null +++ b/src/fftw3/rdft/codelets/r2hc/r2hcII_10.c @@ -0,0 +1,112 @@ +/* + * 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 21:58:12 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_r2hc -compact -variables 4 -n 10 -name r2hcII_10 -dft-II -include r2hcII.h */ + +/* + * This function contains 32 FP additions, 12 FP multiplications, + * (or, 26 additions, 6 multiplications, 6 fused multiply/add), + * 21 stack variables, and 20 memory accesses + */ +/* + * Generator Id's : + * $Id: r2hcII_10.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: r2hcII_10.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: r2hcII_10.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + */ + +#include "r2hcII.h" + +static void r2hcII_10(const R *I, R *ro, R *io, stride is, stride ros, stride ios, int v, int ivs, int ovs) +{ + DK(KP250000000, +0.250000000000000000000000000000000000000000000); + DK(KP587785252, +0.587785252292473129168705954639072768597652438); + DK(KP951056516, +0.951056516295153572116439333379382143405698634); + DK(KP559016994, +0.559016994374947424102293417182819058860154590); + int i; + for (i = v; i > 0; i = i - 1, I = I + ivs, ro = ro + ovs, io = io + ovs) { + E T1, To, T8, Tq, T9, Tp, Te, Ts, Th, Tn; + T1 = I[0]; + To = I[WS(is, 5)]; + { + E T2, T3, T4, T5, T6, T7; + T2 = I[WS(is, 4)]; + T3 = I[WS(is, 6)]; + T4 = T2 - T3; + T5 = I[WS(is, 8)]; + T6 = I[WS(is, 2)]; + T7 = T5 - T6; + T8 = T4 + T7; + Tq = T5 + T6; + T9 = KP559016994 * (T4 - T7); + Tp = T2 + T3; + } + { + E Tc, Td, Tm, Tf, Tg, Tl; + Tc = I[WS(is, 1)]; + Td = I[WS(is, 9)]; + Tm = Tc + Td; + Tf = I[WS(is, 3)]; + Tg = I[WS(is, 7)]; + Tl = Tf + Tg; + Te = Tc - Td; + Ts = KP559016994 * (Tm + Tl); + Th = Tf - Tg; + Tn = Tl - Tm; + } + ro[WS(ros, 2)] = T1 + T8; + io[WS(ios, 2)] = Tn - To; + { + E Ti, Tk, Tb, Tj, Ta; + Ti = FMA(KP951056516, Te, KP587785252 * Th); + Tk = FNMS(KP587785252, Te, KP951056516 * Th); + Ta = FNMS(KP250000000, T8, T1); + Tb = T9 + Ta; + Tj = Ta - T9; + ro[WS(ros, 4)] = Tb - Ti; + ro[WS(ros, 3)] = Tj + Tk; + ro[0] = Tb + Ti; + ro[WS(ros, 1)] = Tj - Tk; + } + { + E Tr, Tw, Tu, Tv, Tt; + Tr = FMA(KP951056516, Tp, KP587785252 * Tq); + Tw = FNMS(KP587785252, Tp, KP951056516 * Tq); + Tt = FMA(KP250000000, Tn, To); + Tu = Ts + Tt; + Tv = Tt - Ts; + io[0] = -(Tr + Tu); + io[WS(ios, 3)] = Tw + Tv; + io[WS(ios, 4)] = Tr - Tu; + io[WS(ios, 1)] = Tv - Tw; + } + } +} + +static const kr2hc_desc desc = { 10, "r2hcII_10", {26, 6, 6, 0}, &GENUS, 0, 0, 0, 0, 0 }; + +void X(codelet_r2hcII_10) (planner *p) { + X(kr2hcII_register) (p, r2hcII_10, &desc); +} diff --git a/src/fftw3/rdft/codelets/r2hc/r2hcII_12.c b/src/fftw3/rdft/codelets/r2hc/r2hcII_12.c new file mode 100644 index 0000000..9e01c7b --- /dev/null +++ b/src/fftw3/rdft/codelets/r2hc/r2hcII_12.c @@ -0,0 +1,128 @@ +/* + * 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 21:58:14 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_r2hc -compact -variables 4 -n 12 -name r2hcII_12 -dft-II -include r2hcII.h */ + +/* + * This function contains 43 FP additions, 12 FP multiplications, + * (or, 39 additions, 8 multiplications, 4 fused multiply/add), + * 28 stack variables, and 24 memory accesses + */ +/* + * Generator Id's : + * $Id: r2hcII_12.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: r2hcII_12.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: r2hcII_12.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + */ + +#include "r2hcII.h" + +static void r2hcII_12(const R *I, R *ro, R *io, stride is, stride ros, stride ios, int v, int ivs, int ovs) +{ + DK(KP353553390, +0.353553390593273762200422181052424519642417969); + DK(KP707106781, +0.707106781186547524400844362104849039284835938); + DK(KP612372435, +0.612372435695794524549321018676472847991486870); + DK(KP500000000, +0.500000000000000000000000000000000000000000000); + DK(KP866025403, +0.866025403784438646763723170752936183471402627); + int i; + for (i = v; i > 0; i = i - 1, I = I + ivs, ro = ro + ovs, io = io + ovs) { + E Tx, Tg, T4, Tz, Ty, Tj, TA, T9, Tm, Tl, Te, Tp, To, Tf, TE; + E TF; + { + E T1, T3, T2, Th, Ti; + T1 = I[0]; + T3 = I[WS(is, 4)]; + T2 = I[WS(is, 8)]; + Tx = KP866025403 * (T2 + T3); + Tg = FMA(KP500000000, T3 - T2, T1); + T4 = T1 + T2 - T3; + Tz = I[WS(is, 6)]; + Th = I[WS(is, 10)]; + Ti = I[WS(is, 2)]; + Ty = Th + Ti; + Tj = KP866025403 * (Th - Ti); + TA = FMA(KP500000000, Ty, Tz); + } + { + E T5, T6, T7, T8; + T5 = I[WS(is, 3)]; + T6 = I[WS(is, 11)]; + T7 = I[WS(is, 7)]; + T8 = T6 - T7; + T9 = T5 + T8; + Tm = KP612372435 * (T6 + T7); + Tl = FNMS(KP353553390, T8, KP707106781 * T5); + } + { + E Td, Ta, Tb, Tc; + Td = I[WS(is, 9)]; + Ta = I[WS(is, 5)]; + Tb = I[WS(is, 1)]; + Tc = Ta - Tb; + Te = Tc - Td; + Tp = FMA(KP353553390, Tc, KP707106781 * Td); + To = KP612372435 * (Ta + Tb); + } + Tf = KP707106781 * (T9 + Te); + ro[WS(ros, 1)] = T4 - Tf; + ro[WS(ros, 4)] = T4 + Tf; + TE = KP707106781 * (Te - T9); + TF = Tz - Ty; + io[WS(ios, 4)] = TE - TF; + io[WS(ios, 1)] = TE + TF; + { + E Tk, TB, Tr, Tw, Tn, Tq; + Tk = Tg - Tj; + TB = Tx - TA; + Tn = Tl - Tm; + Tq = To - Tp; + Tr = Tn + Tq; + Tw = Tn - Tq; + ro[WS(ros, 5)] = Tk - Tr; + io[WS(ios, 2)] = Tw + TB; + ro[0] = Tk + Tr; + io[WS(ios, 3)] = Tw - TB; + } + { + E Ts, TD, Tv, TC, Tt, Tu; + Ts = Tg + Tj; + TD = Tx + TA; + Tt = To + Tp; + Tu = Tm + Tl; + Tv = Tt - Tu; + TC = Tu + Tt; + ro[WS(ros, 3)] = Ts - Tv; + io[WS(ios, 5)] = TD - TC; + ro[WS(ros, 2)] = Ts + Tv; + io[0] = -(TC + TD); + } + } +} + +static const kr2hc_desc desc = { 12, "r2hcII_12", {39, 8, 4, 0}, &GENUS, 0, 0, 0, 0, 0 }; + +void X(codelet_r2hcII_12) (planner *p) { + X(kr2hcII_register) (p, r2hcII_12, &desc); +} diff --git a/src/fftw3/rdft/codelets/r2hc/r2hcII_15.c b/src/fftw3/rdft/codelets/r2hc/r2hcII_15.c new file mode 100644 index 0000000..72e014a --- /dev/null +++ b/src/fftw3/rdft/codelets/r2hc/r2hcII_15.c @@ -0,0 +1,155 @@ +/* + * 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 21:58:16 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_r2hc -compact -variables 4 -n 15 -name r2hcII_15 -dft-II -include r2hcII.h */ + +/* + * This function contains 72 FP additions, 33 FP multiplications, + * (or, 54 additions, 15 multiplications, 18 fused multiply/add), + * 37 stack variables, and 30 memory accesses + */ +/* + * Generator Id's : + * $Id: r2hcII_15.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: r2hcII_15.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: r2hcII_15.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + */ + +#include "r2hcII.h" + +static void r2hcII_15(const R *I, R *ro, R *io, stride is, stride ros, stride ios, int v, int ivs, int ovs) +{ + DK(KP500000000, +0.500000000000000000000000000000000000000000000); + DK(KP866025403, +0.866025403784438646763723170752936183471402627); + DK(KP809016994, +0.809016994374947424102293417182819058860154590); + DK(KP309016994, +0.309016994374947424102293417182819058860154590); + DK(KP250000000, +0.250000000000000000000000000000000000000000000); + DK(KP559016994, +0.559016994374947424102293417182819058860154590); + DK(KP587785252, +0.587785252292473129168705954639072768597652438); + DK(KP951056516, +0.951056516295153572116439333379382143405698634); + int i; + for (i = v; i > 0; i = i - 1, I = I + ivs, ro = ro + ovs, io = io + ovs) { + E T1, T2, Tx, TR, TE, T7, TD, Th, Tm, Tr, TQ, TA, TB, Tf, Te; + E Tu, TS, Td, TH, TO; + T1 = I[WS(is, 10)]; + { + E T3, Tv, T6, Tw, T4, T5; + T2 = I[WS(is, 4)]; + T3 = I[WS(is, 1)]; + Tv = T2 + T3; + T4 = I[WS(is, 7)]; + T5 = I[WS(is, 13)]; + T6 = T4 + T5; + Tw = T4 - T5; + Tx = FMA(KP951056516, Tv, KP587785252 * Tw); + TR = FNMS(KP587785252, Tv, KP951056516 * Tw); + TE = KP559016994 * (T3 - T6); + T7 = T3 + T6; + TD = KP250000000 * T7; + } + { + E Ti, Tl, Tj, Tk, Tp, Tq; + Th = I[0]; + Ti = I[WS(is, 9)]; + Tl = I[WS(is, 12)]; + Tj = I[WS(is, 3)]; + Tk = I[WS(is, 6)]; + Tp = Tk + Ti; + Tq = Tl + Tj; + Tm = Ti + Tj - (Tk + Tl); + Tr = FMA(KP951056516, Tp, KP587785252 * Tq); + TQ = FNMS(KP951056516, Tq, KP587785252 * Tp); + TA = FMA(KP250000000, Tm, Th); + TB = KP559016994 * (Tl + Ti - (Tk + Tj)); + } + { + E T9, Tt, Tc, Ts, Ta, Tb, TG; + Tf = I[WS(is, 5)]; + T9 = I[WS(is, 14)]; + Te = I[WS(is, 11)]; + Tt = T9 + Te; + Ta = I[WS(is, 2)]; + Tb = I[WS(is, 8)]; + Tc = Ta + Tb; + Ts = Ta - Tb; + Tu = FNMS(KP951056516, Tt, KP587785252 * Ts); + TS = FMA(KP951056516, Ts, KP587785252 * Tt); + Td = T9 + Tc; + TG = KP559016994 * (T9 - Tc); + TH = FNMS(KP309016994, Te, TG) + FNMA(KP250000000, Td, Tf); + TO = FMS(KP809016994, Te, Tf) + FNMA(KP250000000, Td, TG); + } + { + E Tn, T8, Tg, To; + Tn = Th - Tm; + T8 = T1 + T2 - T7; + Tg = Td - Te - Tf; + To = T8 + Tg; + io[WS(ios, 2)] = KP866025403 * (T8 - Tg); + ro[WS(ros, 2)] = FNMS(KP500000000, To, Tn); + ro[WS(ros, 7)] = Tn + To; + } + { + E TM, TX, TT, TV, TP, TU, TN, TW; + TM = TB + TA; + TX = KP866025403 * (TR + TS); + TT = TR - TS; + TV = FMS(KP500000000, TT, TQ); + TN = T1 + TE + FNMS(KP809016994, T2, TD); + TP = TN + TO; + TU = KP866025403 * (TO - TN); + ro[WS(ros, 1)] = TM + TP; + io[WS(ios, 1)] = TQ + TT; + io[WS(ios, 6)] = TU - TV; + io[WS(ios, 3)] = TU + TV; + TW = FNMS(KP500000000, TP, TM); + ro[WS(ros, 3)] = TW - TX; + ro[WS(ros, 6)] = TW + TX; + } + { + E Tz, TC, Ty, TK, TI, TL, TF, TJ; + Tz = KP866025403 * (Tx + Tu); + TC = TA - TB; + Ty = Tu - Tx; + TK = FMS(KP500000000, Ty, Tr); + TF = FMA(KP309016994, T2, T1) + TD - TE; + TI = TF + TH; + TL = KP866025403 * (TH - TF); + io[WS(ios, 4)] = Tr + Ty; + ro[WS(ros, 4)] = TC + TI; + io[WS(ios, 5)] = TK - TL; + io[0] = TK + TL; + TJ = FNMS(KP500000000, TI, TC); + ro[0] = Tz + TJ; + ro[WS(ros, 5)] = TJ - Tz; + } + } +} + +static const kr2hc_desc desc = { 15, "r2hcII_15", {54, 15, 18, 0}, &GENUS, 0, 0, 0, 0, 0 }; + +void X(codelet_r2hcII_15) (planner *p) { + X(kr2hcII_register) (p, r2hcII_15, &desc); +} diff --git a/src/fftw3/rdft/codelets/r2hc/r2hcII_16.c b/src/fftw3/rdft/codelets/r2hc/r2hcII_16.c new file mode 100644 index 0000000..4535bde --- /dev/null +++ b/src/fftw3/rdft/codelets/r2hc/r2hcII_16.c @@ -0,0 +1,171 @@ +/* + * 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 21:58:21 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_r2hc -compact -variables 4 -n 16 -name r2hcII_16 -dft-II -include r2hcII.h */ + +/* + * This function contains 66 FP additions, 30 FP multiplications, + * (or, 54 additions, 18 multiplications, 12 fused multiply/add), + * 32 stack variables, and 32 memory accesses + */ +/* + * Generator Id's : + * $Id: r2hcII_16.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: r2hcII_16.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: r2hcII_16.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + */ + +#include "r2hcII.h" + +static void r2hcII_16(const R *I, R *ro, R *io, stride is, stride ros, stride ios, int v, int ivs, int ovs) +{ + DK(KP555570233, +0.555570233019602224742830813948532874374937191); + DK(KP831469612, +0.831469612302545237078788377617905756738560812); + DK(KP980785280, +0.980785280403230449126182236134239036973933731); + DK(KP195090322, +0.195090322016128267848284868477022240927691618); + DK(KP382683432, +0.382683432365089771728459984030398866761344562); + DK(KP923879532, +0.923879532511286756128183189396788286822416626); + DK(KP707106781, +0.707106781186547524400844362104849039284835938); + int i; + for (i = v; i > 0; i = i - 1, I = I + ivs, ro = ro + ovs, io = io + ovs) { + E T5, T11, TB, TV, Tr, TK, Tu, TJ, Ti, TH, Tl, TG, Tc, T10, TE; + E TS; + { + E T1, TU, T4, TT, T2, T3; + T1 = I[0]; + TU = I[WS(is, 8)]; + T2 = I[WS(is, 4)]; + T3 = I[WS(is, 12)]; + T4 = KP707106781 * (T2 - T3); + TT = KP707106781 * (T2 + T3); + T5 = T1 + T4; + T11 = TU - TT; + TB = T1 - T4; + TV = TT + TU; + } + { + E Tq, Tt, Tp, Ts, Tn, To; + Tq = I[WS(is, 15)]; + Tt = I[WS(is, 7)]; + Tn = I[WS(is, 3)]; + To = I[WS(is, 11)]; + Tp = KP707106781 * (Tn - To); + Ts = KP707106781 * (Tn + To); + Tr = Tp - Tq; + TK = Tt - Ts; + Tu = Ts + Tt; + TJ = Tp + Tq; + } + { + E Te, Tk, Th, Tj, Tf, Tg; + Te = I[WS(is, 1)]; + Tk = I[WS(is, 9)]; + Tf = I[WS(is, 5)]; + Tg = I[WS(is, 13)]; + Th = KP707106781 * (Tf - Tg); + Tj = KP707106781 * (Tf + Tg); + Ti = Te + Th; + TH = Tk - Tj; + Tl = Tj + Tk; + TG = Te - Th; + } + { + E T8, TC, Tb, TD; + { + E T6, T7, T9, Ta; + T6 = I[WS(is, 2)]; + T7 = I[WS(is, 10)]; + T8 = FNMS(KP382683432, T7, KP923879532 * T6); + TC = FMA(KP382683432, T6, KP923879532 * T7); + T9 = I[WS(is, 6)]; + Ta = I[WS(is, 14)]; + Tb = FNMS(KP923879532, Ta, KP382683432 * T9); + TD = FMA(KP923879532, T9, KP382683432 * Ta); + } + Tc = T8 + Tb; + T10 = Tb - T8; + TE = TC - TD; + TS = TC + TD; + } + { + E Td, TW, Tw, TR, Tm, Tv; + Td = T5 - Tc; + TW = TS + TV; + Tm = FMA(KP195090322, Ti, KP980785280 * Tl); + Tv = FNMS(KP980785280, Tu, KP195090322 * Tr); + Tw = Tm + Tv; + TR = Tv - Tm; + ro[WS(ros, 4)] = Td - Tw; + io[WS(ios, 7)] = TR + TW; + ro[WS(ros, 3)] = Td + Tw; + io[0] = TR - TW; + } + { + E Tx, TY, TA, TX, Ty, Tz; + Tx = T5 + Tc; + TY = TV - TS; + Ty = FNMS(KP195090322, Tl, KP980785280 * Ti); + Tz = FMA(KP980785280, Tr, KP195090322 * Tu); + TA = Ty + Tz; + TX = Tz - Ty; + ro[WS(ros, 7)] = Tx - TA; + io[WS(ios, 3)] = TX + TY; + ro[0] = Tx + TA; + io[WS(ios, 4)] = TX - TY; + } + { + E TF, T12, TM, TZ, TI, TL; + TF = TB + TE; + T12 = T10 - T11; + TI = FMA(KP831469612, TG, KP555570233 * TH); + TL = FMA(KP831469612, TJ, KP555570233 * TK); + TM = TI - TL; + TZ = TI + TL; + ro[WS(ros, 6)] = TF - TM; + io[WS(ios, 2)] = T12 - TZ; + ro[WS(ros, 1)] = TF + TM; + io[WS(ios, 5)] = -(TZ + T12); + } + { + E TN, T14, TQ, T13, TO, TP; + TN = TB - TE; + T14 = T10 + T11; + TO = FNMS(KP555570233, TJ, KP831469612 * TK); + TP = FNMS(KP555570233, TG, KP831469612 * TH); + TQ = TO - TP; + T13 = TP + TO; + ro[WS(ros, 5)] = TN - TQ; + io[WS(ios, 1)] = T13 + T14; + ro[WS(ros, 2)] = TN + TQ; + io[WS(ios, 6)] = T13 - T14; + } + } +} + +static const kr2hc_desc desc = { 16, "r2hcII_16", {54, 18, 12, 0}, &GENUS, 0, 0, 0, 0, 0 }; + +void X(codelet_r2hcII_16) (planner *p) { + X(kr2hcII_register) (p, r2hcII_16, &desc); +} diff --git a/src/fftw3/rdft/codelets/r2hc/r2hcII_2.c b/src/fftw3/rdft/codelets/r2hc/r2hcII_2.c new file mode 100644 index 0000000..00ca93b --- /dev/null +++ b/src/fftw3/rdft/codelets/r2hc/r2hcII_2.c @@ -0,0 +1,58 @@ +/* + * 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 21:58:02 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_r2hc -compact -variables 4 -n 2 -name r2hcII_2 -dft-II -include r2hcII.h */ + +/* + * This function contains 0 FP additions, 0 FP multiplications, + * (or, 0 additions, 0 multiplications, 0 fused multiply/add), + * 3 stack variables, and 4 memory accesses + */ +/* + * Generator Id's : + * $Id: r2hcII_2.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: r2hcII_2.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: r2hcII_2.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + */ + +#include "r2hcII.h" + +static void r2hcII_2(const R *I, R *ro, R *io, stride is, stride ros, stride ios, int v, int ivs, int ovs) +{ + int i; + for (i = v; i > 0; i = i - 1, I = I + ivs, ro = ro + ovs, io = io + ovs) { + E T1, T2; + T1 = I[0]; + ro[0] = T1; + T2 = I[WS(is, 1)]; + io[0] = -T2; + } +} + +static const kr2hc_desc desc = { 2, "r2hcII_2", {0, 0, 0, 0}, &GENUS, 0, 0, 0, 0, 0 }; + +void X(codelet_r2hcII_2) (planner *p) { + X(kr2hcII_register) (p, r2hcII_2, &desc); +} diff --git a/src/fftw3/rdft/codelets/r2hc/r2hcII_3.c b/src/fftw3/rdft/codelets/r2hc/r2hcII_3.c new file mode 100644 index 0000000..afdc6d1 --- /dev/null +++ b/src/fftw3/rdft/codelets/r2hc/r2hcII_3.c @@ -0,0 +1,63 @@ +/* + * 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 21:58:02 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_r2hc -compact -variables 4 -n 3 -name r2hcII_3 -dft-II -include r2hcII.h */ + +/* + * This function contains 4 FP additions, 2 FP multiplications, + * (or, 3 additions, 1 multiplications, 1 fused multiply/add), + * 7 stack variables, and 6 memory accesses + */ +/* + * Generator Id's : + * $Id: r2hcII_3.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: r2hcII_3.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: r2hcII_3.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + */ + +#include "r2hcII.h" + +static void r2hcII_3(const R *I, R *ro, R *io, stride is, stride ros, stride ios, int v, int ivs, int ovs) +{ + DK(KP500000000, +0.500000000000000000000000000000000000000000000); + DK(KP866025403, +0.866025403784438646763723170752936183471402627); + int i; + for (i = v; i > 0; i = i - 1, I = I + ivs, ro = ro + ovs, io = io + ovs) { + E T1, T2, T3, T4; + T1 = I[0]; + T2 = I[WS(is, 1)]; + T3 = I[WS(is, 2)]; + T4 = T2 - T3; + ro[WS(ros, 1)] = T1 - T4; + io[0] = -(KP866025403 * (T2 + T3)); + ro[0] = FMA(KP500000000, T4, T1); + } +} + +static const kr2hc_desc desc = { 3, "r2hcII_3", {3, 1, 1, 0}, &GENUS, 0, 0, 0, 0, 0 }; + +void X(codelet_r2hcII_3) (planner *p) { + X(kr2hcII_register) (p, r2hcII_3, &desc); +} diff --git a/src/fftw3/rdft/codelets/r2hc/r2hcII_32.c b/src/fftw3/rdft/codelets/r2hc/r2hcII_32.c new file mode 100644 index 0000000..728ae3d --- /dev/null +++ b/src/fftw3/rdft/codelets/r2hc/r2hcII_32.c @@ -0,0 +1,358 @@ +/* + * 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 21:58:28 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_r2hc -compact -variables 4 -n 32 -name r2hcII_32 -dft-II -include r2hcII.h */ + +/* + * This function contains 174 FP additions, 82 FP multiplications, + * (or, 138 additions, 46 multiplications, 36 fused multiply/add), + * 62 stack variables, and 64 memory accesses + */ +/* + * Generator Id's : + * $Id: r2hcII_32.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: r2hcII_32.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: r2hcII_32.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + */ + +#include "r2hcII.h" + +static void r2hcII_32(const R *I, R *ro, R *io, stride is, stride ros, stride ios, int v, int ivs, int ovs) +{ + DK(KP471396736, +0.471396736825997648556387625905254377657460319); + DK(KP881921264, +0.881921264348355029712756863660388349508442621); + DK(KP634393284, +0.634393284163645498215171613225493370675687095); + DK(KP773010453, +0.773010453362736960810906609758469800971041293); + DK(KP290284677, +0.290284677254462367636192375817395274691476278); + DK(KP956940335, +0.956940335732208864935797886980269969482849206); + DK(KP995184726, +0.995184726672196886244836953109479921575474869); + DK(KP098017140, +0.098017140329560601994195563888641845861136673); + 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 = v; i > 0; i = i - 1, I = I + ivs, ro = ro + ovs, io = io + ovs) { + E T5, T2D, T1z, T2q, Tc, T2C, T1C, T2n, Tm, T1k, T1J, T26, Tv, T1l, T1G; + E T27, T15, T1r, T1Y, T2e, T1c, T1s, T1V, T2d, TK, T1o, T1R, T2b, TR, T1p; + E T1O, T2a; + { + E T1, T2p, T4, T2o, T2, T3; + T1 = I[0]; + T2p = I[WS(is, 16)]; + T2 = I[WS(is, 8)]; + T3 = I[WS(is, 24)]; + T4 = KP707106781 * (T2 - T3); + T2o = KP707106781 * (T2 + T3); + T5 = T1 + T4; + T2D = T2p - T2o; + T1z = T1 - T4; + T2q = T2o + T2p; + } + { + E T8, T1A, Tb, T1B; + { + E T6, T7, T9, Ta; + T6 = I[WS(is, 4)]; + T7 = I[WS(is, 20)]; + T8 = FNMS(KP382683432, T7, KP923879532 * T6); + T1A = FMA(KP382683432, T6, KP923879532 * T7); + T9 = I[WS(is, 12)]; + Ta = I[WS(is, 28)]; + Tb = FNMS(KP923879532, Ta, KP382683432 * T9); + T1B = FMA(KP923879532, T9, KP382683432 * Ta); + } + Tc = T8 + Tb; + T2C = Tb - T8; + T1C = T1A - T1B; + T2n = T1A + T1B; + } + { + E Te, Tk, Th, Tj, Tf, Tg; + Te = I[WS(is, 2)]; + Tk = I[WS(is, 18)]; + Tf = I[WS(is, 10)]; + Tg = I[WS(is, 26)]; + Th = KP707106781 * (Tf - Tg); + Tj = KP707106781 * (Tf + Tg); + { + E Ti, Tl, T1H, T1I; + Ti = Te + Th; + Tl = Tj + Tk; + Tm = FNMS(KP195090322, Tl, KP980785280 * Ti); + T1k = FMA(KP195090322, Ti, KP980785280 * Tl); + T1H = Tk - Tj; + T1I = Te - Th; + T1J = FNMS(KP555570233, T1I, KP831469612 * T1H); + T26 = FMA(KP831469612, T1I, KP555570233 * T1H); + } + } + { + E Tq, Tt, Tp, Ts, Tn, To; + Tq = I[WS(is, 30)]; + Tt = I[WS(is, 14)]; + Tn = I[WS(is, 6)]; + To = I[WS(is, 22)]; + Tp = KP707106781 * (Tn - To); + Ts = KP707106781 * (Tn + To); + { + E Tr, Tu, T1E, T1F; + Tr = Tp - Tq; + Tu = Ts + Tt; + Tv = FMA(KP980785280, Tr, KP195090322 * Tu); + T1l = FNMS(KP980785280, Tu, KP195090322 * Tr); + T1E = Tt - Ts; + T1F = Tp + Tq; + T1G = FNMS(KP555570233, T1F, KP831469612 * T1E); + T27 = FMA(KP831469612, T1F, KP555570233 * T1E); + } + } + { + E TW, T1a, TV, T19, T10, T16, T13, T17, TT, TU; + TW = I[WS(is, 31)]; + T1a = I[WS(is, 15)]; + TT = I[WS(is, 7)]; + TU = I[WS(is, 23)]; + TV = KP707106781 * (TT - TU); + T19 = KP707106781 * (TT + TU); + { + E TY, TZ, T11, T12; + TY = I[WS(is, 3)]; + TZ = I[WS(is, 19)]; + T10 = FNMS(KP382683432, TZ, KP923879532 * TY); + T16 = FMA(KP382683432, TY, KP923879532 * TZ); + T11 = I[WS(is, 11)]; + T12 = I[WS(is, 27)]; + T13 = FNMS(KP923879532, T12, KP382683432 * T11); + T17 = FMA(KP923879532, T11, KP382683432 * T12); + } + { + E TX, T14, T1W, T1X; + TX = TV - TW; + T14 = T10 + T13; + T15 = TX + T14; + T1r = TX - T14; + T1W = T13 - T10; + T1X = T1a - T19; + T1Y = T1W - T1X; + T2e = T1W + T1X; + } + { + E T18, T1b, T1T, T1U; + T18 = T16 + T17; + T1b = T19 + T1a; + T1c = T18 + T1b; + T1s = T1b - T18; + T1T = TV + TW; + T1U = T16 - T17; + T1V = T1T + T1U; + T2d = T1U - T1T; + } + } + { + E Ty, TP, TB, TO, TF, TL, TI, TM, Tz, TA; + Ty = I[WS(is, 1)]; + TP = I[WS(is, 17)]; + Tz = I[WS(is, 9)]; + TA = I[WS(is, 25)]; + TB = KP707106781 * (Tz - TA); + TO = KP707106781 * (Tz + TA); + { + E TD, TE, TG, TH; + TD = I[WS(is, 5)]; + TE = I[WS(is, 21)]; + TF = FNMS(KP382683432, TE, KP923879532 * TD); + TL = FMA(KP382683432, TD, KP923879532 * TE); + TG = I[WS(is, 13)]; + TH = I[WS(is, 29)]; + TI = FNMS(KP923879532, TH, KP382683432 * TG); + TM = FMA(KP923879532, TG, KP382683432 * TH); + } + { + E TC, TJ, T1P, T1Q; + TC = Ty + TB; + TJ = TF + TI; + TK = TC + TJ; + T1o = TC - TJ; + T1P = TI - TF; + T1Q = TP - TO; + T1R = T1P - T1Q; + T2b = T1P + T1Q; + } + { + E TN, TQ, T1M, T1N; + TN = TL + TM; + TQ = TO + TP; + TR = TN + TQ; + T1p = TQ - TN; + T1M = Ty - TB; + T1N = TL - TM; + T1O = T1M - T1N; + T2a = T1M + T1N; + } + } + { + E Tx, T1f, T2s, T2u, T1e, T2l, T1i, T2t; + { + E Td, Tw, T2m, T2r; + Td = T5 + Tc; + Tw = Tm + Tv; + Tx = Td - Tw; + T1f = Td + Tw; + T2m = T1l - T1k; + T2r = T2n + T2q; + T2s = T2m - T2r; + T2u = T2m + T2r; + } + { + E TS, T1d, T1g, T1h; + TS = FMA(KP098017140, TK, KP995184726 * TR); + T1d = FNMS(KP995184726, T1c, KP098017140 * T15); + T1e = TS + T1d; + T2l = T1d - TS; + T1g = FNMS(KP098017140, TR, KP995184726 * TK); + T1h = FMA(KP995184726, T15, KP098017140 * T1c); + T1i = T1g + T1h; + T2t = T1h - T1g; + } + ro[WS(ros, 8)] = Tx - T1e; + io[WS(ios, 8)] = T2t - T2u; + ro[WS(ros, 7)] = Tx + T1e; + io[WS(ios, 7)] = T2t + T2u; + ro[WS(ros, 15)] = T1f - T1i; + io[WS(ios, 15)] = T2l - T2s; + ro[0] = T1f + T1i; + io[0] = T2l + T2s; + } + { + E T29, T2h, T2M, T2O, T2g, T2J, T2k, T2N; + { + E T25, T28, T2K, T2L; + T25 = T1z + T1C; + T28 = T26 - T27; + T29 = T25 + T28; + T2h = T25 - T28; + T2K = T1J + T1G; + T2L = T2C + T2D; + T2M = T2K - T2L; + T2O = T2K + T2L; + } + { + E T2c, T2f, T2i, T2j; + T2c = FMA(KP956940335, T2a, KP290284677 * T2b); + T2f = FNMS(KP290284677, T2e, KP956940335 * T2d); + T2g = T2c + T2f; + T2J = T2f - T2c; + T2i = FMA(KP290284677, T2d, KP956940335 * T2e); + T2j = FNMS(KP290284677, T2a, KP956940335 * T2b); + T2k = T2i - T2j; + T2N = T2j + T2i; + } + ro[WS(ros, 14)] = T29 - T2g; + io[WS(ios, 14)] = T2N - T2O; + ro[WS(ros, 1)] = T29 + T2g; + io[WS(ios, 1)] = T2N + T2O; + ro[WS(ros, 9)] = T2h - T2k; + io[WS(ios, 9)] = T2J - T2M; + ro[WS(ros, 6)] = T2h + T2k; + io[WS(ios, 6)] = T2J + T2M; + } + { + E T1n, T1v, T2y, T2A, T1u, T2v, T1y, T2z; + { + E T1j, T1m, T2w, T2x; + T1j = T5 - Tc; + T1m = T1k + T1l; + T1n = T1j + T1m; + T1v = T1j - T1m; + T2w = Tv - Tm; + T2x = T2q - T2n; + T2y = T2w - T2x; + T2A = T2w + T2x; + } + { + E T1q, T1t, T1w, T1x; + T1q = FMA(KP773010453, T1o, KP634393284 * T1p); + T1t = FNMS(KP634393284, T1s, KP773010453 * T1r); + T1u = T1q + T1t; + T2v = T1t - T1q; + T1w = FMA(KP634393284, T1r, KP773010453 * T1s); + T1x = FNMS(KP634393284, T1o, KP773010453 * T1p); + T1y = T1w - T1x; + T2z = T1x + T1w; + } + ro[WS(ros, 12)] = T1n - T1u; + io[WS(ios, 12)] = T2z - T2A; + ro[WS(ros, 3)] = T1n + T1u; + io[WS(ios, 3)] = T2z + T2A; + ro[WS(ros, 11)] = T1v - T1y; + io[WS(ios, 11)] = T2v - T2y; + ro[WS(ros, 4)] = T1v + T1y; + io[WS(ios, 4)] = T2v + T2y; + } + { + E T1L, T21, T2G, T2I, T20, T2H, T24, T2B; + { + E T1D, T1K, T2E, T2F; + T1D = T1z - T1C; + T1K = T1G - T1J; + T1L = T1D + T1K; + T21 = T1D - T1K; + T2E = T2C - T2D; + T2F = T26 + T27; + T2G = T2E - T2F; + T2I = T2F + T2E; + } + { + E T1S, T1Z, T22, T23; + T1S = FMA(KP881921264, T1O, KP471396736 * T1R); + T1Z = FMA(KP881921264, T1V, KP471396736 * T1Y); + T20 = T1S - T1Z; + T2H = T1S + T1Z; + T22 = FNMS(KP471396736, T1V, KP881921264 * T1Y); + T23 = FNMS(KP471396736, T1O, KP881921264 * T1R); + T24 = T22 - T23; + T2B = T23 + T22; + } + ro[WS(ros, 13)] = T1L - T20; + io[WS(ios, 13)] = T2B - T2G; + ro[WS(ros, 2)] = T1L + T20; + io[WS(ios, 2)] = T2B + T2G; + ro[WS(ros, 10)] = T21 - T24; + io[WS(ios, 10)] = T2I - T2H; + ro[WS(ros, 5)] = T21 + T24; + io[WS(ios, 5)] = -(T2H + T2I); + } + } +} + +static const kr2hc_desc desc = { 32, "r2hcII_32", {138, 46, 36, 0}, &GENUS, 0, 0, 0, 0, 0 }; + +void X(codelet_r2hcII_32) (planner *p) { + X(kr2hcII_register) (p, r2hcII_32, &desc); +} diff --git a/src/fftw3/rdft/codelets/r2hc/r2hcII_4.c b/src/fftw3/rdft/codelets/r2hc/r2hcII_4.c new file mode 100644 index 0000000..94aaf84 --- /dev/null +++ b/src/fftw3/rdft/codelets/r2hc/r2hcII_4.c @@ -0,0 +1,65 @@ +/* + * 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 21:58:02 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_r2hc -compact -variables 4 -n 4 -name r2hcII_4 -dft-II -include r2hcII.h */ + +/* + * This function contains 6 FP additions, 2 FP multiplications, + * (or, 6 additions, 2 multiplications, 0 fused multiply/add), + * 8 stack variables, and 8 memory accesses + */ +/* + * Generator Id's : + * $Id: r2hcII_4.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: r2hcII_4.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: r2hcII_4.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + */ + +#include "r2hcII.h" + +static void r2hcII_4(const R *I, R *ro, R *io, stride is, stride ros, stride ios, int v, int ivs, int ovs) +{ + DK(KP707106781, +0.707106781186547524400844362104849039284835938); + int i; + for (i = v; i > 0; i = i - 1, I = I + ivs, ro = ro + ovs, io = io + ovs) { + E T1, T6, T4, T5, T2, T3; + T1 = I[0]; + T6 = I[WS(is, 2)]; + T2 = I[WS(is, 1)]; + T3 = I[WS(is, 3)]; + T4 = KP707106781 * (T2 - T3); + T5 = KP707106781 * (T2 + T3); + ro[WS(ros, 1)] = T1 - T4; + io[WS(ios, 1)] = T6 - T5; + ro[0] = T1 + T4; + io[0] = -(T5 + T6); + } +} + +static const kr2hc_desc desc = { 4, "r2hcII_4", {6, 2, 0, 0}, &GENUS, 0, 0, 0, 0, 0 }; + +void X(codelet_r2hcII_4) (planner *p) { + X(kr2hcII_register) (p, r2hcII_4, &desc); +} diff --git a/src/fftw3/rdft/codelets/r2hc/r2hcII_5.c b/src/fftw3/rdft/codelets/r2hc/r2hcII_5.c new file mode 100644 index 0000000..bb40e64 --- /dev/null +++ b/src/fftw3/rdft/codelets/r2hc/r2hcII_5.c @@ -0,0 +1,78 @@ +/* + * 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 21:58:03 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_r2hc -compact -variables 4 -n 5 -name r2hcII_5 -dft-II -include r2hcII.h */ + +/* + * This function contains 12 FP additions, 6 FP multiplications, + * (or, 9 additions, 3 multiplications, 3 fused multiply/add), + * 17 stack variables, and 10 memory accesses + */ +/* + * Generator Id's : + * $Id: r2hcII_5.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: r2hcII_5.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: r2hcII_5.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + */ + +#include "r2hcII.h" + +static void r2hcII_5(const R *I, R *ro, R *io, stride is, stride ros, stride ios, int v, int ivs, int ovs) +{ + DK(KP250000000, +0.250000000000000000000000000000000000000000000); + DK(KP559016994, +0.559016994374947424102293417182819058860154590); + DK(KP951056516, +0.951056516295153572116439333379382143405698634); + DK(KP587785252, +0.587785252292473129168705954639072768597652438); + int i; + for (i = v; i > 0; i = i - 1, I = I + ivs, ro = ro + ovs, io = io + ovs) { + E T8, T3, T6, T9, Tc, Tb, T7, Ta; + T8 = I[0]; + { + E T1, T2, T4, T5; + T1 = I[WS(is, 2)]; + T2 = I[WS(is, 3)]; + T3 = T1 - T2; + T4 = I[WS(is, 4)]; + T5 = I[WS(is, 1)]; + T6 = T4 - T5; + T9 = T3 + T6; + Tc = T4 + T5; + Tb = T1 + T2; + } + ro[WS(ros, 2)] = T8 + T9; + io[WS(ios, 1)] = FNMS(KP951056516, Tc, KP587785252 * Tb); + io[0] = -(FMA(KP951056516, Tb, KP587785252 * Tc)); + T7 = KP559016994 * (T3 - T6); + Ta = FNMS(KP250000000, T9, T8); + ro[0] = T7 + Ta; + ro[WS(ros, 1)] = Ta - T7; + } +} + +static const kr2hc_desc desc = { 5, "r2hcII_5", {9, 3, 3, 0}, &GENUS, 0, 0, 0, 0, 0 }; + +void X(codelet_r2hcII_5) (planner *p) { + X(kr2hcII_register) (p, r2hcII_5, &desc); +} diff --git a/src/fftw3/rdft/codelets/r2hc/r2hcII_6.c b/src/fftw3/rdft/codelets/r2hc/r2hcII_6.c new file mode 100644 index 0000000..04e76c9 --- /dev/null +++ b/src/fftw3/rdft/codelets/r2hc/r2hcII_6.c @@ -0,0 +1,73 @@ +/* + * 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 21:58:03 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_r2hc -compact -variables 4 -n 6 -name r2hcII_6 -dft-II -include r2hcII.h */ + +/* + * This function contains 13 FP additions, 4 FP multiplications, + * (or, 11 additions, 2 multiplications, 2 fused multiply/add), + * 14 stack variables, and 12 memory accesses + */ +/* + * Generator Id's : + * $Id: r2hcII_6.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: r2hcII_6.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: r2hcII_6.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + */ + +#include "r2hcII.h" + +static void r2hcII_6(const R *I, R *ro, R *io, stride is, stride ros, stride ios, int v, int ivs, int ovs) +{ + DK(KP500000000, +0.500000000000000000000000000000000000000000000); + DK(KP866025403, +0.866025403784438646763723170752936183471402627); + int i; + for (i = v; i > 0; i = i - 1, I = I + ivs, ro = ro + ovs, io = io + ovs) { + E Ta, T7, T9, T1, T3, T2, T8, T4, T5, T6, Tb; + Ta = I[WS(is, 3)]; + T5 = I[WS(is, 5)]; + T6 = I[WS(is, 1)]; + T7 = KP866025403 * (T5 - T6); + T9 = T5 + T6; + T1 = I[0]; + T3 = I[WS(is, 2)]; + T2 = I[WS(is, 4)]; + T8 = KP866025403 * (T2 + T3); + T4 = FMA(KP500000000, T3 - T2, T1); + ro[0] = T4 - T7; + ro[WS(ros, 2)] = T4 + T7; + io[WS(ios, 1)] = Ta - T9; + ro[WS(ros, 1)] = T1 + T2 - T3; + Tb = FMA(KP500000000, T9, Ta); + io[0] = -(T8 + Tb); + io[WS(ios, 2)] = T8 - Tb; + } +} + +static const kr2hc_desc desc = { 6, "r2hcII_6", {11, 2, 2, 0}, &GENUS, 0, 0, 0, 0, 0 }; + +void X(codelet_r2hcII_6) (planner *p) { + X(kr2hcII_register) (p, r2hcII_6, &desc); +} diff --git a/src/fftw3/rdft/codelets/r2hc/r2hcII_7.c b/src/fftw3/rdft/codelets/r2hc/r2hcII_7.c new file mode 100644 index 0000000..13fb676 --- /dev/null +++ b/src/fftw3/rdft/codelets/r2hc/r2hcII_7.c @@ -0,0 +1,83 @@ +/* + * 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 21:58:04 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_r2hc -compact -variables 4 -n 7 -name r2hcII_7 -dft-II -include r2hcII.h */ + +/* + * This function contains 24 FP additions, 18 FP multiplications, + * (or, 12 additions, 6 multiplications, 12 fused multiply/add), + * 20 stack variables, and 14 memory accesses + */ +/* + * Generator Id's : + * $Id: r2hcII_7.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: r2hcII_7.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: r2hcII_7.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + */ + +#include "r2hcII.h" + +static void r2hcII_7(const R *I, R *ro, R *io, stride is, stride ros, stride ios, int v, int ivs, int ovs) +{ + DK(KP900968867, +0.900968867902419126236102319507445051165919162); + DK(KP222520933, +0.222520933956314404288902564496794759466355569); + DK(KP623489801, +0.623489801858733530525004884004239810632274731); + DK(KP433883739, +0.433883739117558120475768332848358754609990728); + DK(KP974927912, +0.974927912181823607018131682993931217232785801); + DK(KP781831482, +0.781831482468029808708444526674057750232334519); + int i; + for (i = v; i > 0; i = i - 1, I = I + ivs, ro = ro + ovs, io = io + ovs) { + E T1, Ta, Td, T4, Tb, T7, Tc, T8, T9; + T1 = I[0]; + T8 = I[WS(is, 1)]; + T9 = I[WS(is, 6)]; + Ta = T8 - T9; + Td = T8 + T9; + { + E T2, T3, T5, T6; + T2 = I[WS(is, 2)]; + T3 = I[WS(is, 5)]; + T4 = T2 - T3; + Tb = T2 + T3; + T5 = I[WS(is, 3)]; + T6 = I[WS(is, 4)]; + T7 = T5 - T6; + Tc = T5 + T6; + } + io[0] = -(FMA(KP781831482, Tb, KP974927912 * Tc) + (KP433883739 * Td)); + io[WS(ios, 1)] = FNMS(KP974927912, Td, KP781831482 * Tc) - (KP433883739 * Tb); + ro[0] = FMA(KP623489801, T4, T1) + FMA(KP222520933, T7, KP900968867 * Ta); + io[WS(ios, 2)] = FNMS(KP781831482, Td, KP974927912 * Tb) - (KP433883739 * Tc); + ro[WS(ros, 2)] = FMA(KP900968867, T7, T1) + FNMA(KP623489801, Ta, KP222520933 * T4); + ro[WS(ros, 1)] = FMA(KP222520933, Ta, T1) + FNMA(KP623489801, T7, KP900968867 * T4); + ro[WS(ros, 3)] = T1 + T4 - (T7 + Ta); + } +} + +static const kr2hc_desc desc = { 7, "r2hcII_7", {12, 6, 12, 0}, &GENUS, 0, 0, 0, 0, 0 }; + +void X(codelet_r2hcII_7) (planner *p) { + X(kr2hcII_register) (p, r2hcII_7, &desc); +} diff --git a/src/fftw3/rdft/codelets/r2hc/r2hcII_8.c b/src/fftw3/rdft/codelets/r2hc/r2hcII_8.c new file mode 100644 index 0000000..d6d2aaf --- /dev/null +++ b/src/fftw3/rdft/codelets/r2hc/r2hcII_8.c @@ -0,0 +1,96 @@ +/* + * 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 21:58:04 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_r2hc -compact -variables 4 -n 8 -name r2hcII_8 -dft-II -include r2hcII.h */ + +/* + * This function contains 22 FP additions, 10 FP multiplications, + * (or, 18 additions, 6 multiplications, 4 fused multiply/add), + * 18 stack variables, and 16 memory accesses + */ +/* + * Generator Id's : + * $Id: r2hcII_8.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: r2hcII_8.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: r2hcII_8.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + */ + +#include "r2hcII.h" + +static void r2hcII_8(const R *I, R *ro, R *io, stride is, stride ros, stride ios, int v, int ivs, int ovs) +{ + DK(KP382683432, +0.382683432365089771728459984030398866761344562); + DK(KP923879532, +0.923879532511286756128183189396788286822416626); + DK(KP707106781, +0.707106781186547524400844362104849039284835938); + int i; + for (i = v; i > 0; i = i - 1, I = I + ivs, ro = ro + ovs, io = io + ovs) { + E T1, Tj, T4, Ti, T8, Te, Tb, Tf, T2, T3; + T1 = I[0]; + Tj = I[WS(is, 4)]; + T2 = I[WS(is, 2)]; + T3 = I[WS(is, 6)]; + T4 = KP707106781 * (T2 - T3); + Ti = KP707106781 * (T2 + T3); + { + E T6, T7, T9, Ta; + T6 = I[WS(is, 1)]; + T7 = I[WS(is, 5)]; + T8 = FNMS(KP382683432, T7, KP923879532 * T6); + Te = FMA(KP382683432, T6, KP923879532 * T7); + T9 = I[WS(is, 3)]; + Ta = I[WS(is, 7)]; + Tb = FNMS(KP923879532, Ta, KP382683432 * T9); + Tf = FMA(KP923879532, T9, KP382683432 * Ta); + } + { + E T5, Tc, Th, Tk; + T5 = T1 + T4; + Tc = T8 + Tb; + ro[WS(ros, 3)] = T5 - Tc; + ro[0] = T5 + Tc; + Th = Te + Tf; + Tk = Ti + Tj; + io[0] = -(Th + Tk); + io[WS(ios, 3)] = Tk - Th; + } + { + E Td, Tg, Tl, Tm; + Td = T1 - T4; + Tg = Te - Tf; + ro[WS(ros, 2)] = Td - Tg; + ro[WS(ros, 1)] = Td + Tg; + Tl = Tb - T8; + Tm = Tj - Ti; + io[WS(ios, 2)] = Tl - Tm; + io[WS(ios, 1)] = Tl + Tm; + } + } +} + +static const kr2hc_desc desc = { 8, "r2hcII_8", {18, 6, 4, 0}, &GENUS, 0, 0, 0, 0, 0 }; + +void X(codelet_r2hcII_8) (planner *p) { + X(kr2hcII_register) (p, r2hcII_8, &desc); +} diff --git a/src/fftw3/rdft/codelets/r2hc/r2hcII_9.c b/src/fftw3/rdft/codelets/r2hc/r2hcII_9.c new file mode 100644 index 0000000..a046b93 --- /dev/null +++ b/src/fftw3/rdft/codelets/r2hc/r2hcII_9.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 21:58:09 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_r2hc -compact -variables 4 -n 9 -name r2hcII_9 -dft-II -include r2hcII.h */ + +/* + * This function contains 42 FP additions, 30 FP multiplications, + * (or, 25 additions, 13 multiplications, 17 fused multiply/add), + * 39 stack variables, and 18 memory accesses + */ +/* + * Generator Id's : + * $Id: r2hcII_9.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: r2hcII_9.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: r2hcII_9.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + */ + +#include "r2hcII.h" + +static void r2hcII_9(const R *I, R *ro, R *io, stride is, stride ros, stride ios, int v, int ivs, int ovs) +{ + DK(KP663413948, +0.663413948168938396205421319635891297216863310); + DK(KP642787609, +0.642787609686539326322643409907263432907559884); + DK(KP556670399, +0.556670399226419366452912952047023132968291906); + DK(KP766044443, +0.766044443118978035202392650555416673935832457); + DK(KP852868531, +0.852868531952443209628250963940074071936020296); + DK(KP173648177, +0.173648177666930348851716626769314796000375677); + DK(KP984807753, +0.984807753012208059366743024589523013670643252); + DK(KP150383733, +0.150383733180435296639271897612501926072238258); + DK(KP813797681, +0.813797681349373692844693217248393223289101568); + DK(KP342020143, +0.342020143325668733044099614682259580763083368); + DK(KP939692620, +0.939692620785908384054109277324731469936208134); + DK(KP296198132, +0.296198132726023843175338011893050938967728390); + DK(KP866025403, +0.866025403784438646763723170752936183471402627); + DK(KP500000000, +0.500000000000000000000000000000000000000000000); + int i; + for (i = v; i > 0; i = i - 1, I = I + ivs, ro = ro + ovs, io = io + ovs) { + E T1, T4, To, Ta, Tl, Tk, Tf, Ti, Th, T2, T3, T5, Tg; + T1 = I[0]; + T2 = I[WS(is, 3)]; + T3 = I[WS(is, 6)]; + T4 = T2 - T3; + To = T2 + T3; + { + E T6, T7, T8, T9; + T6 = I[WS(is, 2)]; + T7 = I[WS(is, 5)]; + T8 = I[WS(is, 8)]; + T9 = T7 - T8; + Ta = T6 - T9; + Tl = T7 + T8; + Tk = FMA(KP500000000, T9, T6); + } + { + E Tb, Tc, Td, Te; + Tb = I[WS(is, 4)]; + Tc = I[WS(is, 1)]; + Td = I[WS(is, 7)]; + Te = Tc + Td; + Tf = Tb - Te; + Ti = FMA(KP500000000, Te, Tb); + Th = Tc - Td; + } + io[WS(ios, 1)] = KP866025403 * (Tf - Ta); + T5 = T1 - T4; + Tg = Ta + Tf; + ro[WS(ros, 1)] = FNMS(KP500000000, Tg, T5); + ro[WS(ros, 4)] = T5 + Tg; + { + E Tr, Tt, Tw, Tv, Tu, Tp, Tq, Ts, Tj, Tm, Tn; + Tr = FMA(KP500000000, T4, T1); + Tt = FMA(KP296198132, Th, KP939692620 * Ti); + Tw = FNMS(KP813797681, Th, KP342020143 * Ti); + Tv = FNMS(KP984807753, Tk, KP150383733 * Tl); + Tu = FMA(KP173648177, Tk, KP852868531 * Tl); + Tp = FNMS(KP556670399, Tl, KP766044443 * Tk); + Tq = FMA(KP852868531, Th, KP173648177 * Ti); + Ts = Tp + Tq; + Tj = FNMS(KP984807753, Ti, KP150383733 * Th); + Tm = FMA(KP642787609, Tk, KP663413948 * Tl); + Tn = Tj - Tm; + io[0] = FNMS(KP866025403, To, Tn); + ro[0] = Tr + Ts; + io[WS(ios, 3)] = FNMS(KP500000000, Tn, KP866025403 * ((Tp - Tq) - To)); + ro[WS(ros, 3)] = FMA(KP866025403, Tm + Tj, Tr) - (KP500000000 * Ts); + io[WS(ios, 2)] = FMA(KP866025403, To - (Tu + Tt), KP500000000 * (Tw - Tv)); + ro[WS(ros, 2)] = FMA(KP500000000, Tt - Tu, Tr) + (KP866025403 * (Tv + Tw)); + } + } +} + +static const kr2hc_desc desc = { 9, "r2hcII_9", {25, 13, 17, 0}, &GENUS, 0, 0, 0, 0, 0 }; + +void X(codelet_r2hcII_9) (planner *p) { + X(kr2hcII_register) (p, r2hcII_9, &desc); +} diff --git a/src/fftw3/rdft/codelets/r2hc/r2hc_10.c b/src/fftw3/rdft/codelets/r2hc/r2hc_10.c new file mode 100644 index 0000000..38e1766 --- /dev/null +++ b/src/fftw3/rdft/codelets/r2hc/r2hc_10.c @@ -0,0 +1,115 @@ +/* + * 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 21:56:41 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_r2hc -compact -variables 4 -n 10 -name r2hc_10 -include r2hc.h */ + +/* + * This function contains 34 FP additions, 12 FP multiplications, + * (or, 28 additions, 6 multiplications, 6 fused multiply/add), + * 26 stack variables, and 20 memory accesses + */ +/* + * Generator Id's : + * $Id: r2hc_10.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: r2hc_10.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: r2hc_10.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + */ + +#include "r2hc.h" + +static void r2hc_10(const R *I, R *ro, R *io, stride is, stride ros, stride ios, int v, int ivs, int ovs) +{ + DK(KP250000000, +0.250000000000000000000000000000000000000000000); + DK(KP559016994, +0.559016994374947424102293417182819058860154590); + DK(KP951056516, +0.951056516295153572116439333379382143405698634); + DK(KP587785252, +0.587785252292473129168705954639072768597652438); + int i; + for (i = v; i > 0; i = i - 1, I = I + ivs, ro = ro + ovs, io = io + ovs) { + E Ti, Tt, Ta, Tn, Td, To, Te, Tv, T3, Tq, T6, Tr, T7, Tu, Tg; + E Th; + Tg = I[0]; + Th = I[WS(is, 5)]; + Ti = Tg - Th; + Tt = Tg + Th; + { + E T8, T9, Tb, Tc; + T8 = I[WS(is, 4)]; + T9 = I[WS(is, 9)]; + Ta = T8 - T9; + Tn = T8 + T9; + Tb = I[WS(is, 6)]; + Tc = I[WS(is, 1)]; + Td = Tb - Tc; + To = Tb + Tc; + } + Te = Ta + Td; + Tv = Tn + To; + { + E T1, T2, T4, T5; + T1 = I[WS(is, 2)]; + T2 = I[WS(is, 7)]; + T3 = T1 - T2; + Tq = T1 + T2; + T4 = I[WS(is, 8)]; + T5 = I[WS(is, 3)]; + T6 = T4 - T5; + Tr = T4 + T5; + } + T7 = T3 + T6; + Tu = Tq + Tr; + { + E Tl, Tm, Tf, Tj, Tk; + Tl = Td - Ta; + Tm = T3 - T6; + io[WS(ios, 1)] = FNMS(KP951056516, Tm, KP587785252 * Tl); + io[WS(ios, 3)] = FMA(KP587785252, Tm, KP951056516 * Tl); + Tf = KP559016994 * (T7 - Te); + Tj = T7 + Te; + Tk = FNMS(KP250000000, Tj, Ti); + ro[WS(ros, 1)] = Tf + Tk; + ro[WS(ros, 5)] = Ti + Tj; + ro[WS(ros, 3)] = Tk - Tf; + } + { + E Tp, Ts, Ty, Tw, Tx; + Tp = Tn - To; + Ts = Tq - Tr; + io[WS(ios, 2)] = FNMS(KP587785252, Ts, KP951056516 * Tp); + io[WS(ios, 4)] = FMA(KP951056516, Ts, KP587785252 * Tp); + Ty = KP559016994 * (Tu - Tv); + Tw = Tu + Tv; + Tx = FNMS(KP250000000, Tw, Tt); + ro[WS(ros, 2)] = Tx - Ty; + ro[0] = Tt + Tw; + ro[WS(ros, 4)] = Ty + Tx; + } + } +} + +static const kr2hc_desc desc = { 10, "r2hc_10", {28, 6, 6, 0}, &GENUS, 0, 0, 0, 0, 0 }; + +void X(codelet_r2hc_10) (planner *p) { + X(kr2hc_register) (p, r2hc_10, &desc); +} diff --git a/src/fftw3/rdft/codelets/r2hc/r2hc_11.c b/src/fftw3/rdft/codelets/r2hc/r2hc_11.c new file mode 100644 index 0000000..cceb091 --- /dev/null +++ b/src/fftw3/rdft/codelets/r2hc/r2hc_11.c @@ -0,0 +1,102 @@ +/* + * 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 21:56:41 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_r2hc -compact -variables 4 -n 11 -name r2hc_11 -include r2hc.h */ + +/* + * This function contains 60 FP additions, 50 FP multiplications, + * (or, 20 additions, 10 multiplications, 40 fused multiply/add), + * 28 stack variables, and 22 memory accesses + */ +/* + * Generator Id's : + * $Id: r2hc_11.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: r2hc_11.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: r2hc_11.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + */ + +#include "r2hc.h" + +static void r2hc_11(const R *I, R *ro, R *io, stride is, stride ros, stride ios, int v, int ivs, int ovs) +{ + DK(KP654860733, +0.654860733945285064056925072466293553183791199); + DK(KP142314838, +0.142314838273285140443792668616369668791051361); + DK(KP959492973, +0.959492973614497389890368057066327699062454848); + DK(KP415415013, +0.415415013001886425529274149229623203524004910); + DK(KP841253532, +0.841253532831181168861811648919367717513292498); + DK(KP989821441, +0.989821441880932732376092037776718787376519372); + DK(KP909631995, +0.909631995354518371411715383079028460060241051); + DK(KP281732556, +0.281732556841429697711417915346616899035777899); + DK(KP540640817, +0.540640817455597582107635954318691695431770608); + DK(KP755749574, +0.755749574354258283774035843972344420179717445); + int i; + for (i = v; i > 0; i = i - 1, I = I + ivs, ro = ro + ovs, io = io + ovs) { + E T1, T4, Tl, Tg, Th, Td, Ti, Ta, Tk, T7, Tj, Tb, Tc; + T1 = I[0]; + { + E T2, T3, Te, Tf; + T2 = I[WS(is, 2)]; + T3 = I[WS(is, 9)]; + T4 = T2 + T3; + Tl = T3 - T2; + Te = I[WS(is, 1)]; + Tf = I[WS(is, 10)]; + Tg = Te + Tf; + Th = Tf - Te; + } + Tb = I[WS(is, 3)]; + Tc = I[WS(is, 8)]; + Td = Tb + Tc; + Ti = Tc - Tb; + { + E T8, T9, T5, T6; + T8 = I[WS(is, 5)]; + T9 = I[WS(is, 6)]; + Ta = T8 + T9; + Tk = T9 - T8; + T5 = I[WS(is, 4)]; + T6 = I[WS(is, 7)]; + T7 = T5 + T6; + Tj = T6 - T5; + } + io[WS(ios, 4)] = FMA(KP755749574, Th, KP540640817 * Ti) + FNMS(KP909631995, Tk, KP281732556 * Tj) - (KP989821441 * Tl); + ro[WS(ros, 4)] = FMA(KP841253532, Td, T1) + FNMS(KP959492973, T7, KP415415013 * Ta) + FNMA(KP142314838, T4, KP654860733 * Tg); + io[WS(ios, 2)] = FMA(KP909631995, Th, KP755749574 * Tl) + FNMA(KP540640817, Tk, KP989821441 * Tj) - (KP281732556 * Ti); + io[WS(ios, 5)] = FMA(KP281732556, Th, KP755749574 * Ti) + FNMS(KP909631995, Tj, KP989821441 * Tk) - (KP540640817 * Tl); + io[WS(ios, 1)] = FMA(KP540640817, Th, KP909631995 * Tl) + FMA(KP989821441, Ti, KP755749574 * Tj) + (KP281732556 * Tk); + io[WS(ios, 3)] = FMA(KP989821441, Th, KP540640817 * Tj) + FNMS(KP909631995, Ti, KP755749574 * Tk) - (KP281732556 * Tl); + ro[WS(ros, 3)] = FMA(KP415415013, Td, T1) + FNMS(KP654860733, Ta, KP841253532 * T7) + FNMA(KP959492973, T4, KP142314838 * Tg); + ro[WS(ros, 1)] = FMA(KP841253532, Tg, T1) + FNMS(KP959492973, Ta, KP415415013 * T4) + FNMA(KP654860733, T7, KP142314838 * Td); + ro[0] = T1 + Tg + T4 + Td + T7 + Ta; + ro[WS(ros, 2)] = FMA(KP415415013, Tg, T1) + FNMS(KP142314838, T7, KP841253532 * Ta) + FNMA(KP959492973, Td, KP654860733 * T4); + ro[WS(ros, 5)] = FMA(KP841253532, T4, T1) + FNMS(KP142314838, Ta, KP415415013 * T7) + FNMA(KP654860733, Td, KP959492973 * Tg); + } +} + +static const kr2hc_desc desc = { 11, "r2hc_11", {20, 10, 40, 0}, &GENUS, 0, 0, 0, 0, 0 }; + +void X(codelet_r2hc_11) (planner *p) { + X(kr2hc_register) (p, r2hc_11, &desc); +} diff --git a/src/fftw3/rdft/codelets/r2hc/r2hc_12.c b/src/fftw3/rdft/codelets/r2hc/r2hc_12.c new file mode 100644 index 0000000..81a5273 --- /dev/null +++ b/src/fftw3/rdft/codelets/r2hc/r2hc_12.c @@ -0,0 +1,124 @@ +/* + * 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 21:56:41 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_r2hc -compact -variables 4 -n 12 -name r2hc_12 -include r2hc.h */ + +/* + * This function contains 38 FP additions, 8 FP multiplications, + * (or, 34 additions, 4 multiplications, 4 fused multiply/add), + * 21 stack variables, and 24 memory accesses + */ +/* + * Generator Id's : + * $Id: r2hc_12.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: r2hc_12.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: r2hc_12.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + */ + +#include "r2hc.h" + +static void r2hc_12(const R *I, R *ro, R *io, stride is, stride ros, stride ios, int v, int ivs, int ovs) +{ + DK(KP866025403, +0.866025403784438646763723170752936183471402627); + DK(KP500000000, +0.500000000000000000000000000000000000000000000); + int i; + for (i = v; i > 0; i = i - 1, I = I + ivs, ro = ro + ovs, io = io + ovs) { + E T5, Tp, Tb, Tn, Ty, Tt, Ta, Tq, Tc, Ti, Tz, Tu, Td, To; + { + E T1, T2, T3, T4; + T1 = I[0]; + T2 = I[WS(is, 4)]; + T3 = I[WS(is, 8)]; + T4 = T2 + T3; + T5 = T1 + T4; + Tp = FNMS(KP500000000, T4, T1); + Tb = T3 - T2; + } + { + E Tj, Tk, Tl, Tm; + Tj = I[WS(is, 3)]; + Tk = I[WS(is, 7)]; + Tl = I[WS(is, 11)]; + Tm = Tk + Tl; + Tn = FNMS(KP500000000, Tm, Tj); + Ty = Tl - Tk; + Tt = Tj + Tm; + } + { + E T6, T7, T8, T9; + T6 = I[WS(is, 6)]; + T7 = I[WS(is, 10)]; + T8 = I[WS(is, 2)]; + T9 = T7 + T8; + Ta = T6 + T9; + Tq = FNMS(KP500000000, T9, T6); + Tc = T8 - T7; + } + { + E Te, Tf, Tg, Th; + Te = I[WS(is, 9)]; + Tf = I[WS(is, 1)]; + Tg = I[WS(is, 5)]; + Th = Tf + Tg; + Ti = FNMS(KP500000000, Th, Te); + Tz = Tg - Tf; + Tu = Te + Th; + } + ro[WS(ros, 3)] = T5 - Ta; + io[WS(ios, 3)] = Tt - Tu; + Td = KP866025403 * (Tb - Tc); + To = Ti - Tn; + io[WS(ios, 1)] = Td + To; + io[WS(ios, 5)] = To - Td; + { + E Tx, TA, Tv, Tw; + Tx = Tp - Tq; + TA = KP866025403 * (Ty - Tz); + ro[WS(ros, 5)] = Tx - TA; + ro[WS(ros, 1)] = Tx + TA; + Tv = T5 + Ta; + Tw = Tt + Tu; + ro[WS(ros, 6)] = Tv - Tw; + ro[0] = Tv + Tw; + } + { + E Tr, Ts, TB, TC; + Tr = Tp + Tq; + Ts = Tn + Ti; + ro[WS(ros, 2)] = Tr - Ts; + ro[WS(ros, 4)] = Tr + Ts; + TB = Ty + Tz; + TC = Tb + Tc; + io[WS(ios, 2)] = KP866025403 * (TB - TC); + io[WS(ios, 4)] = KP866025403 * (TC + TB); + } + } +} + +static const kr2hc_desc desc = { 12, "r2hc_12", {34, 4, 4, 0}, &GENUS, 0, 0, 0, 0, 0 }; + +void X(codelet_r2hc_12) (planner *p) { + X(kr2hc_register) (p, r2hc_12, &desc); +} diff --git a/src/fftw3/rdft/codelets/r2hc/r2hc_13.c b/src/fftw3/rdft/codelets/r2hc/r2hc_13.c new file mode 100644 index 0000000..deb7914 --- /dev/null +++ b/src/fftw3/rdft/codelets/r2hc/r2hc_13.c @@ -0,0 +1,194 @@ +/* + * 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 21:56:41 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_r2hc -compact -variables 4 -n 13 -name r2hc_13 -include r2hc.h */ + +/* + * This function contains 76 FP additions, 34 FP multiplications, + * (or, 57 additions, 15 multiplications, 19 fused multiply/add), + * 55 stack variables, and 26 memory accesses + */ +/* + * Generator Id's : + * $Id: r2hc_13.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: r2hc_13.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: r2hc_13.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + */ + +#include "r2hc.h" + +static void r2hc_13(const R *I, R *ro, R *io, stride is, stride ros, stride ios, int v, int ivs, int ovs) +{ + DK(KP083333333, +0.083333333333333333333333333333333333333333333); + DK(KP075902986, +0.075902986037193865983102897245103540356428373); + DK(KP251768516, +0.251768516431883313623436926934233488546674281); + DK(KP503537032, +0.503537032863766627246873853868466977093348562); + DK(KP113854479, +0.113854479055790798974654345867655310534642560); + DK(KP265966249, +0.265966249214837287587521063842185948798330267); + DK(KP387390585, +0.387390585467617292130675966426762851778775217); + DK(KP300462606, +0.300462606288665774426601772289207995520941381); + DK(KP132983124, +0.132983124607418643793760531921092974399165133); + DK(KP258260390, +0.258260390311744861420450644284508567852516811); + DK(KP2_000000000, +2.000000000000000000000000000000000000000000000); + DK(KP1_732050807, +1.732050807568877293527446341505872366942805254); + DK(KP300238635, +0.300238635966332641462884626667381504676006424); + DK(KP011599105, +0.011599105605768290721655456654083252189827041); + DK(KP156891391, +0.156891391051584611046832726756003269660212636); + DK(KP256247671, +0.256247671582936600958684654061725059144125175); + DK(KP174138601, +0.174138601152135905005660794929264742616964676); + DK(KP575140729, +0.575140729474003121368385547455453388461001608); + DK(KP866025403, +0.866025403784438646763723170752936183471402627); + DK(KP500000000, +0.500000000000000000000000000000000000000000000); + int i; + for (i = v; i > 0; i = i - 1, I = I + ivs, ro = ro + ovs, io = io + ovs) { + E T13, Tb, Tm, TW, TX, T14, TU, T10, Tz, TB, Tu, TC, TR, T11; + T13 = I[0]; + { + E Te, TO, Ta, Tv, To, T5, Tw, Tp, Th, Tr, Tk, Ts, Tl, TP, Tc; + E Td; + Tc = I[WS(is, 8)]; + Td = I[WS(is, 5)]; + Te = Tc - Td; + TO = Tc + Td; + { + E T6, T7, T8, T9; + T6 = I[WS(is, 1)]; + T7 = I[WS(is, 3)]; + T8 = I[WS(is, 9)]; + T9 = T7 + T8; + Ta = T6 + T9; + Tv = T7 - T8; + To = FNMS(KP500000000, T9, T6); + } + { + E T1, T2, T3, T4; + T1 = I[WS(is, 12)]; + T2 = I[WS(is, 10)]; + T3 = I[WS(is, 4)]; + T4 = T2 + T3; + T5 = T1 + T4; + Tw = T2 - T3; + Tp = FNMS(KP500000000, T4, T1); + } + { + E Tf, Tg, Ti, Tj; + Tf = I[WS(is, 11)]; + Tg = I[WS(is, 6)]; + Th = Tf - Tg; + Tr = Tf + Tg; + Ti = I[WS(is, 7)]; + Tj = I[WS(is, 2)]; + Tk = Ti - Tj; + Ts = Ti + Tj; + } + Tl = Th + Tk; + TP = Tr + Ts; + Tb = T5 - Ta; + Tm = Te + Tl; + TW = Ta + T5; + TX = TO + TP; + T14 = TW + TX; + { + E TS, TT, Tx, Ty; + TS = Tv + Tw; + TT = Th - Tk; + TU = TS - TT; + T10 = TS + TT; + Tx = KP866025403 * (Tv - Tw); + Ty = FNMS(KP500000000, Tl, Te); + Tz = Tx + Ty; + TB = Ty - Tx; + } + { + E Tq, Tt, TN, TQ; + Tq = To - Tp; + Tt = KP866025403 * (Tr - Ts); + Tu = Tq - Tt; + TC = Tq + Tt; + TN = To + Tp; + TQ = FNMS(KP500000000, TP, TO); + TR = TN - TQ; + T11 = TN + TQ; + } + } + ro[0] = T13 + T14; + { + E Tn, TG, TE, TF, TJ, TM, TK, TL; + Tn = FNMS(KP174138601, Tm, KP575140729 * Tb); + TG = FMA(KP174138601, Tb, KP575140729 * Tm); + { + E TA, TD, TH, TI; + TA = FNMS(KP156891391, Tz, KP256247671 * Tu); + TD = FNMS(KP300238635, TC, KP011599105 * TB); + TE = TA + TD; + TF = KP1_732050807 * (TD - TA); + TH = FMA(KP300238635, TB, KP011599105 * TC); + TI = FMA(KP256247671, Tz, KP156891391 * Tu); + TJ = TH - TI; + TM = KP1_732050807 * (TI + TH); + } + io[WS(ios, 5)] = FMA(KP2_000000000, TE, Tn); + io[WS(ios, 1)] = FMA(KP2_000000000, TJ, TG); + TK = TG - TJ; + io[WS(ios, 4)] = TF - TK; + io[WS(ios, 3)] = TF + TK; + TL = Tn - TE; + io[WS(ios, 2)] = TL - TM; + io[WS(ios, 6)] = TL + TM; + } + { + E TZ, T1b, T19, T1e, T16, T1a, TV, TY, T1c, T1d; + TV = FNMS(KP132983124, TU, KP258260390 * TR); + TY = KP300462606 * (TW - TX); + TZ = FMA(KP2_000000000, TV, TY); + T1b = TY - TV; + { + E T17, T18, T12, T15; + T17 = FMA(KP387390585, TU, KP265966249 * TR); + T18 = FNMS(KP503537032, T11, KP113854479 * T10); + T19 = T17 - T18; + T1e = T17 + T18; + T12 = FMA(KP251768516, T10, KP075902986 * T11); + T15 = FNMS(KP083333333, T14, T13); + T16 = FMA(KP2_000000000, T12, T15); + T1a = T15 - T12; + } + ro[WS(ros, 1)] = TZ + T16; + ro[WS(ros, 5)] = T16 - TZ; + T1c = T1a - T1b; + ro[WS(ros, 2)] = T19 + T1c; + ro[WS(ros, 6)] = T1c - T19; + T1d = T1b + T1a; + ro[WS(ros, 3)] = T1d - T1e; + ro[WS(ros, 4)] = T1e + T1d; + } + } +} + +static const kr2hc_desc desc = { 13, "r2hc_13", {57, 15, 19, 0}, &GENUS, 0, 0, 0, 0, 0 }; + +void X(codelet_r2hc_13) (planner *p) { + X(kr2hc_register) (p, r2hc_13, &desc); +} diff --git a/src/fftw3/rdft/codelets/r2hc/r2hc_14.c b/src/fftw3/rdft/codelets/r2hc/r2hc_14.c new file mode 100644 index 0000000..497d84a --- /dev/null +++ b/src/fftw3/rdft/codelets/r2hc/r2hc_14.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 21:56:41 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_r2hc -compact -variables 4 -n 14 -name r2hc_14 -include r2hc.h */ + +/* + * This function contains 62 FP additions, 36 FP multiplications, + * (or, 38 additions, 12 multiplications, 24 fused multiply/add), + * 29 stack variables, and 28 memory accesses + */ +/* + * Generator Id's : + * $Id: r2hc_14.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: r2hc_14.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: r2hc_14.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + */ + +#include "r2hc.h" + +static void r2hc_14(const R *I, R *ro, R *io, stride is, stride ros, stride ios, int v, int ivs, int ovs) +{ + DK(KP900968867, +0.900968867902419126236102319507445051165919162); + DK(KP222520933, +0.222520933956314404288902564496794759466355569); + DK(KP623489801, +0.623489801858733530525004884004239810632274731); + DK(KP433883739, +0.433883739117558120475768332848358754609990728); + DK(KP974927912, +0.974927912181823607018131682993931217232785801); + DK(KP781831482, +0.781831482468029808708444526674057750232334519); + int i; + for (i = v; i > 0; i = i - 1, I = I + ivs, ro = ro + ovs, io = io + ovs) { + E T3, TB, T6, Tv, Tn, Ts, Tk, Tt, Td, Ty, T9, Tw, Tg, Tz, T1; + E T2; + T1 = I[0]; + T2 = I[WS(is, 7)]; + T3 = T1 - T2; + TB = T1 + T2; + { + E T4, T5, Tl, Tm; + T4 = I[WS(is, 4)]; + T5 = I[WS(is, 11)]; + T6 = T4 - T5; + Tv = T4 + T5; + Tl = I[WS(is, 12)]; + Tm = I[WS(is, 5)]; + Tn = Tl - Tm; + Ts = Tl + Tm; + } + { + E Ti, Tj, Tb, Tc; + Ti = I[WS(is, 2)]; + Tj = I[WS(is, 9)]; + Tk = Ti - Tj; + Tt = Ti + Tj; + Tb = I[WS(is, 6)]; + Tc = I[WS(is, 13)]; + Td = Tb - Tc; + Ty = Tb + Tc; + } + { + E T7, T8, Te, Tf; + T7 = I[WS(is, 10)]; + T8 = I[WS(is, 3)]; + T9 = T7 - T8; + Tw = T7 + T8; + Te = I[WS(is, 8)]; + Tf = I[WS(is, 1)]; + Tg = Te - Tf; + Tz = Te + Tf; + } + { + E Tp, Tr, Tq, Ta, To, Th; + Tp = Tn - Tk; + Tr = Tg - Td; + Tq = T9 - T6; + io[WS(ios, 1)] = FMA(KP781831482, Tp, KP974927912 * Tq) + (KP433883739 * Tr); + io[WS(ios, 5)] = FMA(KP433883739, Tq, KP781831482 * Tr) - (KP974927912 * Tp); + io[WS(ios, 3)] = FMA(KP433883739, Tp, KP974927912 * Tr) - (KP781831482 * Tq); + Ta = T6 + T9; + To = Tk + Tn; + Th = Td + Tg; + ro[WS(ros, 3)] = FMA(KP623489801, Ta, T3) + FNMA(KP222520933, Th, KP900968867 * To); + ro[WS(ros, 7)] = T3 + To + Ta + Th; + ro[WS(ros, 1)] = FMA(KP623489801, To, T3) + FNMA(KP900968867, Th, KP222520933 * Ta); + ro[WS(ros, 5)] = FMA(KP623489801, Th, T3) + FNMA(KP900968867, Ta, KP222520933 * To); + } + { + E Tu, TA, Tx, TC, TE, TD; + Tu = Ts - Tt; + TA = Ty - Tz; + Tx = Tv - Tw; + io[WS(ios, 2)] = FMA(KP974927912, Tu, KP433883739 * Tx) + (KP781831482 * TA); + io[WS(ios, 6)] = FMA(KP974927912, Tx, KP433883739 * TA) - (KP781831482 * Tu); + io[WS(ios, 4)] = FNMS(KP781831482, Tx, KP974927912 * TA) - (KP433883739 * Tu); + TC = Tt + Ts; + TE = Tv + Tw; + TD = Ty + Tz; + ro[WS(ros, 6)] = FMA(KP623489801, TC, TB) + FNMA(KP900968867, TD, KP222520933 * TE); + ro[WS(ros, 2)] = FMA(KP623489801, TD, TB) + FNMA(KP900968867, TE, KP222520933 * TC); + ro[WS(ros, 4)] = FMA(KP623489801, TE, TB) + FNMA(KP222520933, TD, KP900968867 * TC); + ro[0] = TB + TC + TE + TD; + } + } +} + +static const kr2hc_desc desc = { 14, "r2hc_14", {38, 12, 24, 0}, &GENUS, 0, 0, 0, 0, 0 }; + +void X(codelet_r2hc_14) (planner *p) { + X(kr2hc_register) (p, r2hc_14, &desc); +} diff --git a/src/fftw3/rdft/codelets/r2hc/r2hc_15.c b/src/fftw3/rdft/codelets/r2hc/r2hc_15.c new file mode 100644 index 0000000..71c4aba --- /dev/null +++ b/src/fftw3/rdft/codelets/r2hc/r2hc_15.c @@ -0,0 +1,168 @@ +/* + * 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 21:56:42 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_r2hc -compact -variables 4 -n 15 -name r2hc_15 -include r2hc.h */ + +/* + * This function contains 64 FP additions, 25 FP multiplications, + * (or, 50 additions, 11 multiplications, 14 fused multiply/add), + * 47 stack variables, and 30 memory accesses + */ +/* + * Generator Id's : + * $Id: r2hc_15.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: r2hc_15.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: r2hc_15.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + */ + +#include "r2hc.h" + +static void r2hc_15(const R *I, R *ro, R *io, stride is, stride ros, stride ios, int v, int ivs, int ovs) +{ + DK(KP484122918, +0.484122918275927110647408174972799951354115213); + DK(KP216506350, +0.216506350946109661690930792688234045867850657); + DK(KP951056516, +0.951056516295153572116439333379382143405698634); + DK(KP587785252, +0.587785252292473129168705954639072768597652438); + DK(KP250000000, +0.250000000000000000000000000000000000000000000); + DK(KP559016994, +0.559016994374947424102293417182819058860154590); + DK(KP509036960, +0.509036960455127183450980863393907648510733164); + DK(KP823639103, +0.823639103546331925877420039278190003029660514); + DK(KP866025403, +0.866025403784438646763723170752936183471402627); + DK(KP500000000, +0.500000000000000000000000000000000000000000000); + int i; + for (i = v; i > 0; i = i - 1, I = I + ivs, ro = ro + ovs, io = io + ovs) { + E Ti, TR, TL, TD, TE, T7, Te, Tf, TV, TW, TX, Tv, Ty, TH, To; + E Tr, TG, TS, TT, TU; + { + E TJ, Tg, Th, TK; + TJ = I[0]; + Tg = I[WS(is, 10)]; + Th = I[WS(is, 5)]; + TK = Th + Tg; + Ti = Tg - Th; + TR = TJ + TK; + TL = FNMS(KP500000000, TK, TJ); + } + { + E Tm, Tt, Tw, Tp, T3, Tx, Ta, Tn, Td, Tq, T6, Tu; + Tm = I[WS(is, 3)]; + Tt = I[WS(is, 6)]; + Tw = I[WS(is, 9)]; + Tp = I[WS(is, 12)]; + { + E T1, T2, T8, T9; + T1 = I[WS(is, 14)]; + T2 = I[WS(is, 4)]; + T3 = T1 - T2; + Tx = T1 + T2; + T8 = I[WS(is, 13)]; + T9 = I[WS(is, 8)]; + Ta = T8 - T9; + Tn = T9 + T8; + } + { + E Tb, Tc, T4, T5; + Tb = I[WS(is, 7)]; + Tc = I[WS(is, 2)]; + Td = Tb - Tc; + Tq = Tc + Tb; + T4 = I[WS(is, 1)]; + T5 = I[WS(is, 11)]; + T6 = T4 - T5; + Tu = T5 + T4; + } + TD = Ta - Td; + TE = T6 + T3; + T7 = T3 - T6; + Te = Ta + Td; + Tf = T7 - Te; + TV = Tt + Tu; + TW = Tw + Tx; + TX = TV + TW; + Tv = FNMS(KP500000000, Tu, Tt); + Ty = FNMS(KP500000000, Tx, Tw); + TH = Tv + Ty; + To = FNMS(KP500000000, Tn, Tm); + Tr = FNMS(KP500000000, Tq, Tp); + TG = To + Tr; + TS = Tm + Tn; + TT = Tp + Tq; + TU = TS + TT; + } + io[WS(ios, 5)] = KP866025403 * (Tf - Ti); + { + E TF, TP, TI, TM, TN, TQ, TO; + TF = FMA(KP823639103, TD, KP509036960 * TE); + TP = FNMS(KP509036960, TD, KP823639103 * TE); + TI = KP559016994 * (TG - TH); + TM = TG + TH; + TN = FNMS(KP250000000, TM, TL); + ro[WS(ros, 5)] = TL + TM; + TQ = TN - TI; + ro[WS(ros, 2)] = TP + TQ; + ro[WS(ros, 7)] = TQ - TP; + TO = TI + TN; + ro[WS(ros, 1)] = TF + TO; + ro[WS(ros, 4)] = TO - TF; + } + { + E T11, T12, T10, TY, TZ; + T11 = TS - TT; + T12 = TW - TV; + io[WS(ios, 3)] = FMA(KP587785252, T11, KP951056516 * T12); + io[WS(ios, 6)] = FNMS(KP951056516, T11, KP587785252 * T12); + T10 = KP559016994 * (TU - TX); + TY = TU + TX; + TZ = FNMS(KP250000000, TY, TR); + ro[WS(ros, 3)] = TZ - T10; + ro[0] = TR + TY; + ro[WS(ros, 6)] = T10 + TZ; + { + E Tl, TB, TA, TC; + { + E Tj, Tk, Ts, Tz; + Tj = FMA(KP866025403, Ti, KP216506350 * Tf); + Tk = KP484122918 * (Te + T7); + Tl = Tj + Tk; + TB = Tk - Tj; + Ts = To - Tr; + Tz = Tv - Ty; + TA = FMA(KP951056516, Ts, KP587785252 * Tz); + TC = FNMS(KP587785252, Ts, KP951056516 * Tz); + } + io[WS(ios, 1)] = Tl - TA; + io[WS(ios, 7)] = TC - TB; + io[WS(ios, 4)] = Tl + TA; + io[WS(ios, 2)] = TB + TC; + } + } + } +} + +static const kr2hc_desc desc = { 15, "r2hc_15", {50, 11, 14, 0}, &GENUS, 0, 0, 0, 0, 0 }; + +void X(codelet_r2hc_15) (planner *p) { + X(kr2hc_register) (p, r2hc_15, &desc); +} diff --git a/src/fftw3/rdft/codelets/r2hc/r2hc_16.c b/src/fftw3/rdft/codelets/r2hc/r2hc_16.c new file mode 100644 index 0000000..e28d6d5 --- /dev/null +++ b/src/fftw3/rdft/codelets/r2hc/r2hc_16.c @@ -0,0 +1,159 @@ +/* + * 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 21:56:43 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_r2hc -compact -variables 4 -n 16 -name r2hc_16 -include r2hc.h */ + +/* + * This function contains 58 FP additions, 12 FP multiplications, + * (or, 54 additions, 8 multiplications, 4 fused multiply/add), + * 34 stack variables, and 32 memory accesses + */ +/* + * Generator Id's : + * $Id: r2hc_16.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: r2hc_16.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: r2hc_16.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + */ + +#include "r2hc.h" + +static void r2hc_16(const R *I, R *ro, R *io, stride is, stride ros, stride ios, int v, int ivs, int ovs) +{ + DK(KP923879532, +0.923879532511286756128183189396788286822416626); + DK(KP382683432, +0.382683432365089771728459984030398866761344562); + DK(KP707106781, +0.707106781186547524400844362104849039284835938); + int i; + for (i = v; i > 0; i = i - 1, I = I + ivs, ro = ro + ovs, io = io + ovs) { + E T3, T6, T7, Tz, Ti, Ta, Td, Te, TA, Th, Tq, TV, TF, TP, Tx; + E TU, TE, TM, Tg, Tf, TJ, TQ; + { + E T1, T2, T4, T5; + T1 = I[0]; + T2 = I[WS(is, 8)]; + T3 = T1 + T2; + T4 = I[WS(is, 4)]; + T5 = I[WS(is, 12)]; + T6 = T4 + T5; + T7 = T3 + T6; + Tz = T1 - T2; + Ti = T4 - T5; + } + { + E T8, T9, Tb, Tc; + T8 = I[WS(is, 2)]; + T9 = I[WS(is, 10)]; + Ta = T8 + T9; + Tg = T8 - T9; + Tb = I[WS(is, 14)]; + Tc = I[WS(is, 6)]; + Td = Tb + Tc; + Tf = Tb - Tc; + } + Te = Ta + Td; + TA = KP707106781 * (Tg + Tf); + Th = KP707106781 * (Tf - Tg); + { + E Tm, TN, Tp, TO; + { + E Tk, Tl, Tn, To; + Tk = I[WS(is, 15)]; + Tl = I[WS(is, 7)]; + Tm = Tk - Tl; + TN = Tk + Tl; + Tn = I[WS(is, 3)]; + To = I[WS(is, 11)]; + Tp = Tn - To; + TO = Tn + To; + } + Tq = FNMS(KP923879532, Tp, KP382683432 * Tm); + TV = TN + TO; + TF = FMA(KP923879532, Tm, KP382683432 * Tp); + TP = TN - TO; + } + { + E Tt, TK, Tw, TL; + { + E Tr, Ts, Tu, Tv; + Tr = I[WS(is, 1)]; + Ts = I[WS(is, 9)]; + Tt = Tr - Ts; + TK = Tr + Ts; + Tu = I[WS(is, 5)]; + Tv = I[WS(is, 13)]; + Tw = Tu - Tv; + TL = Tu + Tv; + } + Tx = FMA(KP382683432, Tt, KP923879532 * Tw); + TU = TK + TL; + TE = FNMS(KP382683432, Tw, KP923879532 * Tt); + TM = TK - TL; + } + ro[WS(ros, 4)] = T7 - Te; + io[WS(ios, 4)] = TV - TU; + { + E Tj, Ty, TD, TG; + Tj = Th - Ti; + Ty = Tq - Tx; + io[WS(ios, 1)] = Tj + Ty; + io[WS(ios, 7)] = Ty - Tj; + TD = Tz + TA; + TG = TE + TF; + ro[WS(ros, 7)] = TD - TG; + ro[WS(ros, 1)] = TD + TG; + } + { + E TB, TC, TH, TI; + TB = Tz - TA; + TC = Tx + Tq; + ro[WS(ros, 5)] = TB - TC; + ro[WS(ros, 3)] = TB + TC; + TH = Ti + Th; + TI = TF - TE; + io[WS(ios, 3)] = TH + TI; + io[WS(ios, 5)] = TI - TH; + } + TJ = T3 - T6; + TQ = KP707106781 * (TM + TP); + ro[WS(ros, 6)] = TJ - TQ; + ro[WS(ros, 2)] = TJ + TQ; + { + E TR, TS, TT, TW; + TR = Td - Ta; + TS = KP707106781 * (TP - TM); + io[WS(ios, 2)] = TR + TS; + io[WS(ios, 6)] = TS - TR; + TT = T7 + Te; + TW = TU + TV; + ro[WS(ros, 8)] = TT - TW; + ro[0] = TT + TW; + } + } +} + +static const kr2hc_desc desc = { 16, "r2hc_16", {54, 8, 4, 0}, &GENUS, 0, 0, 0, 0, 0 }; + +void X(codelet_r2hc_16) (planner *p) { + X(kr2hc_register) (p, r2hc_16, &desc); +} diff --git a/src/fftw3/rdft/codelets/r2hc/r2hc_2.c b/src/fftw3/rdft/codelets/r2hc/r2hc_2.c new file mode 100644 index 0000000..b0d8450 --- /dev/null +++ b/src/fftw3/rdft/codelets/r2hc/r2hc_2.c @@ -0,0 +1,58 @@ +/* + * 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 21:56:40 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_r2hc -compact -variables 4 -n 2 -name r2hc_2 -include r2hc.h */ + +/* + * This function contains 2 FP additions, 0 FP multiplications, + * (or, 2 additions, 0 multiplications, 0 fused multiply/add), + * 3 stack variables, and 4 memory accesses + */ +/* + * Generator Id's : + * $Id: r2hc_2.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: r2hc_2.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: r2hc_2.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + */ + +#include "r2hc.h" + +static void r2hc_2(const R *I, R *ro, R *io, stride is, stride ros, stride ios, int v, int ivs, int ovs) +{ + int i; + for (i = v; i > 0; i = i - 1, I = I + ivs, ro = ro + ovs, io = io + ovs) { + E T1, T2; + T1 = I[0]; + T2 = I[WS(is, 1)]; + ro[WS(ros, 1)] = T1 - T2; + ro[0] = T1 + T2; + } +} + +static const kr2hc_desc desc = { 2, "r2hc_2", {2, 0, 0, 0}, &GENUS, 0, 0, 0, 0, 0 }; + +void X(codelet_r2hc_2) (planner *p) { + X(kr2hc_register) (p, r2hc_2, &desc); +} diff --git a/src/fftw3/rdft/codelets/r2hc/r2hc_3.c b/src/fftw3/rdft/codelets/r2hc/r2hc_3.c new file mode 100644 index 0000000..84041fc --- /dev/null +++ b/src/fftw3/rdft/codelets/r2hc/r2hc_3.c @@ -0,0 +1,63 @@ +/* + * 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 21:56:40 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_r2hc -compact -variables 4 -n 3 -name r2hc_3 -include r2hc.h */ + +/* + * This function contains 4 FP additions, 2 FP multiplications, + * (or, 3 additions, 1 multiplications, 1 fused multiply/add), + * 7 stack variables, and 6 memory accesses + */ +/* + * Generator Id's : + * $Id: r2hc_3.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: r2hc_3.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: r2hc_3.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + */ + +#include "r2hc.h" + +static void r2hc_3(const R *I, R *ro, R *io, stride is, stride ros, stride ios, int v, int ivs, int ovs) +{ + DK(KP866025403, +0.866025403784438646763723170752936183471402627); + DK(KP500000000, +0.500000000000000000000000000000000000000000000); + int i; + for (i = v; i > 0; i = i - 1, I = I + ivs, ro = ro + ovs, io = io + ovs) { + E T1, T2, T3, T4; + T1 = I[0]; + T2 = I[WS(is, 1)]; + T3 = I[WS(is, 2)]; + T4 = T2 + T3; + ro[WS(ros, 1)] = FNMS(KP500000000, T4, T1); + io[WS(ios, 1)] = KP866025403 * (T3 - T2); + ro[0] = T1 + T4; + } +} + +static const kr2hc_desc desc = { 3, "r2hc_3", {3, 1, 1, 0}, &GENUS, 0, 0, 0, 0, 0 }; + +void X(codelet_r2hc_3) (planner *p) { + X(kr2hc_register) (p, r2hc_3, &desc); +} diff --git a/src/fftw3/rdft/codelets/r2hc/r2hc_32.c b/src/fftw3/rdft/codelets/r2hc/r2hc_32.c new file mode 100644 index 0000000..b3e0a9d --- /dev/null +++ b/src/fftw3/rdft/codelets/r2hc/r2hc_32.c @@ -0,0 +1,320 @@ +/* + * 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 21:56:44 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_r2hc -compact -variables 4 -n 32 -name r2hc_32 -include r2hc.h */ + +/* + * This function contains 156 FP additions, 42 FP multiplications, + * (or, 140 additions, 26 multiplications, 16 fused multiply/add), + * 54 stack variables, and 64 memory accesses + */ +/* + * Generator Id's : + * $Id: r2hc_32.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: r2hc_32.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: r2hc_32.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + */ + +#include "r2hc.h" + +static void r2hc_32(const R *I, R *ro, R *io, stride is, stride ros, stride ios, int v, int ivs, int ovs) +{ + 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 = v; i > 0; i = i - 1, I = I + ivs, ro = ro + ovs, io = io + ovs) { + E T7, T2b, Tv, T1l, Te, T2o, Ty, T1k, Tt, T2d, TF, T1h, Tm, T2c, TC; + E T1i, T1Z, T22, T2k, T2j, T1e, T1C, T19, T1B, T1S, T1V, T2h, T2g, TX, T1z; + E TS, T1y; + { + E T1, T2, T3, T4, T5, T6; + T1 = I[0]; + T2 = I[WS(is, 16)]; + T3 = T1 + T2; + T4 = I[WS(is, 8)]; + T5 = I[WS(is, 24)]; + T6 = T4 + T5; + T7 = T3 + T6; + T2b = T3 - T6; + Tv = T1 - T2; + T1l = T4 - T5; + } + { + E Ta, Tw, Td, Tx; + { + E T8, T9, Tb, Tc; + T8 = I[WS(is, 4)]; + T9 = I[WS(is, 20)]; + Ta = T8 + T9; + Tw = T8 - T9; + Tb = I[WS(is, 28)]; + Tc = I[WS(is, 12)]; + Td = Tb + Tc; + Tx = Tb - Tc; + } + Te = Ta + Td; + T2o = Td - Ta; + Ty = KP707106781 * (Tw + Tx); + T1k = KP707106781 * (Tx - Tw); + } + { + E Tp, TD, Ts, TE; + { + E Tn, To, Tq, Tr; + Tn = I[WS(is, 30)]; + To = I[WS(is, 14)]; + Tp = Tn + To; + TD = Tn - To; + Tq = I[WS(is, 6)]; + Tr = I[WS(is, 22)]; + Ts = Tq + Tr; + TE = Tq - Tr; + } + Tt = Tp + Ts; + T2d = Tp - Ts; + TF = FMA(KP923879532, TD, KP382683432 * TE); + T1h = FNMS(KP923879532, TE, KP382683432 * TD); + } + { + E Ti, TA, Tl, TB; + { + E Tg, Th, Tj, Tk; + Tg = I[WS(is, 2)]; + Th = I[WS(is, 18)]; + Ti = Tg + Th; + TA = Tg - Th; + Tj = I[WS(is, 10)]; + Tk = I[WS(is, 26)]; + Tl = Tj + Tk; + TB = Tj - Tk; + } + Tm = Ti + Tl; + T2c = Ti - Tl; + TC = FNMS(KP382683432, TB, KP923879532 * TA); + T1i = FMA(KP382683432, TA, KP923879532 * TB); + } + { + E T11, T1X, T1d, T1Y, T14, T20, T17, T21, T1a, T18; + { + E TZ, T10, T1b, T1c; + TZ = I[WS(is, 31)]; + T10 = I[WS(is, 15)]; + T11 = TZ - T10; + T1X = TZ + T10; + T1b = I[WS(is, 7)]; + T1c = I[WS(is, 23)]; + T1d = T1b - T1c; + T1Y = T1b + T1c; + } + { + E T12, T13, T15, T16; + T12 = I[WS(is, 3)]; + T13 = I[WS(is, 19)]; + T14 = T12 - T13; + T20 = T12 + T13; + T15 = I[WS(is, 27)]; + T16 = I[WS(is, 11)]; + T17 = T15 - T16; + T21 = T15 + T16; + } + T1Z = T1X + T1Y; + T22 = T20 + T21; + T2k = T21 - T20; + T2j = T1X - T1Y; + T1a = KP707106781 * (T17 - T14); + T1e = T1a - T1d; + T1C = T1d + T1a; + T18 = KP707106781 * (T14 + T17); + T19 = T11 + T18; + T1B = T11 - T18; + } + { + E TK, T1Q, TW, T1R, TN, T1T, TQ, T1U, TT, TR; + { + E TI, TJ, TU, TV; + TI = I[WS(is, 1)]; + TJ = I[WS(is, 17)]; + TK = TI - TJ; + T1Q = TI + TJ; + TU = I[WS(is, 9)]; + TV = I[WS(is, 25)]; + TW = TU - TV; + T1R = TU + TV; + } + { + E TL, TM, TO, TP; + TL = I[WS(is, 5)]; + TM = I[WS(is, 21)]; + TN = TL - TM; + T1T = TL + TM; + TO = I[WS(is, 29)]; + TP = I[WS(is, 13)]; + TQ = TO - TP; + T1U = TO + TP; + } + T1S = T1Q + T1R; + T1V = T1T + T1U; + T2h = T1U - T1T; + T2g = T1Q - T1R; + TT = KP707106781 * (TQ - TN); + TX = TT - TW; + T1z = TW + TT; + TR = KP707106781 * (TN + TQ); + TS = TK + TR; + T1y = TK - TR; + } + { + E Tf, Tu, T27, T28, T29, T2a; + Tf = T7 + Te; + Tu = Tm + Tt; + T27 = Tf + Tu; + T28 = T1S + T1V; + T29 = T1Z + T22; + T2a = T28 + T29; + ro[WS(ros, 8)] = Tf - Tu; + io[WS(ios, 8)] = T29 - T28; + ro[WS(ros, 16)] = T27 - T2a; + ro[0] = T27 + T2a; + } + { + E T1P, T25, T24, T26, T1W, T23; + T1P = T7 - Te; + T25 = Tt - Tm; + T1W = T1S - T1V; + T23 = T1Z - T22; + T24 = KP707106781 * (T1W + T23); + T26 = KP707106781 * (T23 - T1W); + ro[WS(ros, 12)] = T1P - T24; + io[WS(ios, 12)] = T26 - T25; + ro[WS(ros, 4)] = T1P + T24; + io[WS(ios, 4)] = T25 + T26; + } + { + E T2f, T2v, T2p, T2r, T2m, T2q, T2u, T2w, T2e, T2n; + T2e = KP707106781 * (T2c + T2d); + T2f = T2b + T2e; + T2v = T2b - T2e; + T2n = KP707106781 * (T2d - T2c); + T2p = T2n - T2o; + T2r = T2o + T2n; + { + E T2i, T2l, T2s, T2t; + T2i = FMA(KP923879532, T2g, KP382683432 * T2h); + T2l = FNMS(KP382683432, T2k, KP923879532 * T2j); + T2m = T2i + T2l; + T2q = T2l - T2i; + T2s = FNMS(KP382683432, T2g, KP923879532 * T2h); + T2t = FMA(KP382683432, T2j, KP923879532 * T2k); + T2u = T2s + T2t; + T2w = T2t - T2s; + } + ro[WS(ros, 14)] = T2f - T2m; + io[WS(ios, 14)] = T2u - T2r; + ro[WS(ros, 2)] = T2f + T2m; + io[WS(ios, 2)] = T2r + T2u; + io[WS(ios, 6)] = T2p + T2q; + ro[WS(ros, 6)] = T2v + T2w; + io[WS(ios, 10)] = T2q - T2p; + ro[WS(ros, 10)] = T2v - T2w; + } + { + E TH, T1t, T1s, T1u, T1g, T1o, T1n, T1p; + { + E Tz, TG, T1q, T1r; + Tz = Tv + Ty; + TG = TC + TF; + TH = Tz + TG; + T1t = Tz - TG; + T1q = FNMS(KP195090322, TS, KP980785280 * TX); + T1r = FMA(KP195090322, T19, KP980785280 * T1e); + T1s = T1q + T1r; + T1u = T1r - T1q; + } + { + E TY, T1f, T1j, T1m; + TY = FMA(KP980785280, TS, KP195090322 * TX); + T1f = FNMS(KP195090322, T1e, KP980785280 * T19); + T1g = TY + T1f; + T1o = T1f - TY; + T1j = T1h - T1i; + T1m = T1k - T1l; + T1n = T1j - T1m; + T1p = T1m + T1j; + } + ro[WS(ros, 15)] = TH - T1g; + io[WS(ios, 15)] = T1s - T1p; + ro[WS(ros, 1)] = TH + T1g; + io[WS(ios, 1)] = T1p + T1s; + io[WS(ios, 7)] = T1n + T1o; + ro[WS(ros, 7)] = T1t + T1u; + io[WS(ios, 9)] = T1o - T1n; + ro[WS(ros, 9)] = T1t - T1u; + } + { + E T1x, T1N, T1M, T1O, T1E, T1I, T1H, T1J; + { + E T1v, T1w, T1K, T1L; + T1v = Tv - Ty; + T1w = T1i + T1h; + T1x = T1v + T1w; + T1N = T1v - T1w; + T1K = FNMS(KP555570233, T1y, KP831469612 * T1z); + T1L = FMA(KP555570233, T1B, KP831469612 * T1C); + T1M = T1K + T1L; + T1O = T1L - T1K; + } + { + E T1A, T1D, T1F, T1G; + T1A = FMA(KP831469612, T1y, KP555570233 * T1z); + T1D = FNMS(KP555570233, T1C, KP831469612 * T1B); + T1E = T1A + T1D; + T1I = T1D - T1A; + T1F = TF - TC; + T1G = T1l + T1k; + T1H = T1F - T1G; + T1J = T1G + T1F; + } + ro[WS(ros, 13)] = T1x - T1E; + io[WS(ios, 13)] = T1M - T1J; + ro[WS(ros, 3)] = T1x + T1E; + io[WS(ios, 3)] = T1J + T1M; + io[WS(ios, 5)] = T1H + T1I; + ro[WS(ros, 5)] = T1N + T1O; + io[WS(ios, 11)] = T1I - T1H; + ro[WS(ros, 11)] = T1N - T1O; + } + } +} + +static const kr2hc_desc desc = { 32, "r2hc_32", {140, 26, 16, 0}, &GENUS, 0, 0, 0, 0, 0 }; + +void X(codelet_r2hc_32) (planner *p) { + X(kr2hc_register) (p, r2hc_32, &desc); +} diff --git a/src/fftw3/rdft/codelets/r2hc/r2hc_4.c b/src/fftw3/rdft/codelets/r2hc/r2hc_4.c new file mode 100644 index 0000000..0ef1567 --- /dev/null +++ b/src/fftw3/rdft/codelets/r2hc/r2hc_4.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 21:56:40 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_r2hc -compact -variables 4 -n 4 -name r2hc_4 -include r2hc.h */ + +/* + * This function contains 6 FP additions, 0 FP multiplications, + * (or, 6 additions, 0 multiplications, 0 fused multiply/add), + * 7 stack variables, and 8 memory accesses + */ +/* + * Generator Id's : + * $Id: r2hc_4.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: r2hc_4.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: r2hc_4.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + */ + +#include "r2hc.h" + +static void r2hc_4(const R *I, R *ro, R *io, stride is, stride ros, stride ios, int v, int ivs, int ovs) +{ + int i; + for (i = v; i > 0; i = i - 1, I = I + ivs, ro = ro + ovs, io = io + ovs) { + E T1, T2, T3, T4, T5, T6; + T1 = I[0]; + T2 = I[WS(is, 2)]; + T3 = T1 + T2; + T4 = I[WS(is, 1)]; + T5 = I[WS(is, 3)]; + T6 = T4 + T5; + ro[WS(ros, 1)] = T1 - T2; + io[WS(ios, 1)] = T5 - T4; + ro[WS(ros, 2)] = T3 - T6; + ro[0] = T3 + T6; + } +} + +static const kr2hc_desc desc = { 4, "r2hc_4", {6, 0, 0, 0}, &GENUS, 0, 0, 0, 0, 0 }; + +void X(codelet_r2hc_4) (planner *p) { + X(kr2hc_register) (p, r2hc_4, &desc); +} diff --git a/src/fftw3/rdft/codelets/r2hc/r2hc_5.c b/src/fftw3/rdft/codelets/r2hc/r2hc_5.c new file mode 100644 index 0000000..14f4849 --- /dev/null +++ b/src/fftw3/rdft/codelets/r2hc/r2hc_5.c @@ -0,0 +1,78 @@ +/* + * 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 21:56:40 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_r2hc -compact -variables 4 -n 5 -name r2hc_5 -include r2hc.h */ + +/* + * This function contains 12 FP additions, 6 FP multiplications, + * (or, 9 additions, 3 multiplications, 3 fused multiply/add), + * 17 stack variables, and 10 memory accesses + */ +/* + * Generator Id's : + * $Id: r2hc_5.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: r2hc_5.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: r2hc_5.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + */ + +#include "r2hc.h" + +static void r2hc_5(const R *I, R *ro, R *io, stride is, stride ros, stride ios, int v, int ivs, int ovs) +{ + DK(KP250000000, +0.250000000000000000000000000000000000000000000); + DK(KP559016994, +0.559016994374947424102293417182819058860154590); + DK(KP587785252, +0.587785252292473129168705954639072768597652438); + DK(KP951056516, +0.951056516295153572116439333379382143405698634); + int i; + for (i = v; i > 0; i = i - 1, I = I + ivs, ro = ro + ovs, io = io + ovs) { + E Ta, T7, T8, T3, Tb, T6, T9, Tc; + Ta = I[0]; + { + E T1, T2, T4, T5; + T1 = I[WS(is, 4)]; + T2 = I[WS(is, 1)]; + T7 = T2 + T1; + T4 = I[WS(is, 2)]; + T5 = I[WS(is, 3)]; + T8 = T4 + T5; + T3 = T1 - T2; + Tb = T7 + T8; + T6 = T4 - T5; + } + io[WS(ios, 1)] = FNMS(KP587785252, T6, KP951056516 * T3); + ro[0] = Ta + Tb; + io[WS(ios, 2)] = FMA(KP587785252, T3, KP951056516 * T6); + T9 = KP559016994 * (T7 - T8); + Tc = FNMS(KP250000000, Tb, Ta); + ro[WS(ros, 1)] = T9 + Tc; + ro[WS(ros, 2)] = Tc - T9; + } +} + +static const kr2hc_desc desc = { 5, "r2hc_5", {9, 3, 3, 0}, &GENUS, 0, 0, 0, 0, 0 }; + +void X(codelet_r2hc_5) (planner *p) { + X(kr2hc_register) (p, r2hc_5, &desc); +} diff --git a/src/fftw3/rdft/codelets/r2hc/r2hc_6.c b/src/fftw3/rdft/codelets/r2hc/r2hc_6.c new file mode 100644 index 0000000..5fadce3 --- /dev/null +++ b/src/fftw3/rdft/codelets/r2hc/r2hc_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 21:56:40 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_r2hc -compact -variables 4 -n 6 -name r2hc_6 -include r2hc.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: r2hc_6.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: r2hc_6.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: r2hc_6.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + */ + +#include "r2hc.h" + +static void r2hc_6(const R *I, R *ro, R *io, stride is, stride ros, stride ios, int v, int ivs, int ovs) +{ + DK(KP500000000, +0.500000000000000000000000000000000000000000000); + DK(KP866025403, +0.866025403784438646763723170752936183471402627); + int i; + for (i = v; i > 0; i = i - 1, I = I + ivs, ro = ro + ovs, io = io + ovs) { + E T3, Td, T9, Tc, T6, Tb, T1, T2, Ta, Te; + T1 = I[0]; + T2 = I[WS(is, 3)]; + T3 = T1 - T2; + Td = T1 + T2; + { + E T7, T8, T4, T5; + T7 = I[WS(is, 4)]; + T8 = I[WS(is, 1)]; + T9 = T7 - T8; + Tc = T7 + T8; + T4 = I[WS(is, 2)]; + T5 = I[WS(is, 5)]; + T6 = T4 - T5; + Tb = T4 + T5; + } + io[WS(ios, 1)] = KP866025403 * (T9 - T6); + Ta = T6 + T9; + ro[WS(ros, 1)] = FNMS(KP500000000, Ta, T3); + ro[WS(ros, 3)] = T3 + Ta; + io[WS(ios, 2)] = KP866025403 * (Tb - Tc); + Te = Tb + Tc; + ro[WS(ros, 2)] = FNMS(KP500000000, Te, Td); + ro[0] = Td + Te; + } +} + +static const kr2hc_desc desc = { 6, "r2hc_6", {12, 2, 2, 0}, &GENUS, 0, 0, 0, 0, 0 }; + +void X(codelet_r2hc_6) (planner *p) { + X(kr2hc_register) (p, r2hc_6, &desc); +} diff --git a/src/fftw3/rdft/codelets/r2hc/r2hc_7.c b/src/fftw3/rdft/codelets/r2hc/r2hc_7.c new file mode 100644 index 0000000..8548e93 --- /dev/null +++ b/src/fftw3/rdft/codelets/r2hc/r2hc_7.c @@ -0,0 +1,83 @@ +/* + * 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 21:56:41 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_r2hc -compact -variables 4 -n 7 -name r2hc_7 -include r2hc.h */ + +/* + * This function contains 24 FP additions, 18 FP multiplications, + * (or, 12 additions, 6 multiplications, 12 fused multiply/add), + * 20 stack variables, and 14 memory accesses + */ +/* + * Generator Id's : + * $Id: r2hc_7.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: r2hc_7.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: r2hc_7.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + */ + +#include "r2hc.h" + +static void r2hc_7(const R *I, R *ro, R *io, stride is, stride ros, stride ios, int v, int ivs, int ovs) +{ + DK(KP222520933, +0.222520933956314404288902564496794759466355569); + DK(KP900968867, +0.900968867902419126236102319507445051165919162); + DK(KP623489801, +0.623489801858733530525004884004239810632274731); + DK(KP433883739, +0.433883739117558120475768332848358754609990728); + DK(KP781831482, +0.781831482468029808708444526674057750232334519); + DK(KP974927912, +0.974927912181823607018131682993931217232785801); + int i; + for (i = v; i > 0; i = i - 1, I = I + ivs, ro = ro + ovs, io = io + ovs) { + E T1, Ta, Tb, T4, Td, T7, Tc, T8, T9; + T1 = I[0]; + T8 = I[WS(is, 1)]; + T9 = I[WS(is, 6)]; + Ta = T8 + T9; + Tb = T9 - T8; + { + E T2, T3, T5, T6; + T2 = I[WS(is, 2)]; + T3 = I[WS(is, 5)]; + T4 = T2 + T3; + Td = T3 - T2; + T5 = I[WS(is, 3)]; + T6 = I[WS(is, 4)]; + T7 = T5 + T6; + Tc = T6 - T5; + } + io[WS(ios, 2)] = FNMS(KP781831482, Tc, KP974927912 * Tb) - (KP433883739 * Td); + io[WS(ios, 1)] = FMA(KP781831482, Tb, KP974927912 * Td) + (KP433883739 * Tc); + ro[WS(ros, 2)] = FMA(KP623489801, T7, T1) + FNMA(KP900968867, T4, KP222520933 * Ta); + io[WS(ios, 3)] = FMA(KP433883739, Tb, KP974927912 * Tc) - (KP781831482 * Td); + ro[WS(ros, 3)] = FMA(KP623489801, T4, T1) + FNMA(KP222520933, T7, KP900968867 * Ta); + ro[WS(ros, 1)] = FMA(KP623489801, Ta, T1) + FNMA(KP900968867, T7, KP222520933 * T4); + ro[0] = T1 + Ta + T4 + T7; + } +} + +static const kr2hc_desc desc = { 7, "r2hc_7", {12, 6, 12, 0}, &GENUS, 0, 0, 0, 0, 0 }; + +void X(codelet_r2hc_7) (planner *p) { + X(kr2hc_register) (p, r2hc_7, &desc); +} diff --git a/src/fftw3/rdft/codelets/r2hc/r2hc_8.c b/src/fftw3/rdft/codelets/r2hc/r2hc_8.c new file mode 100644 index 0000000..b502b94 --- /dev/null +++ b/src/fftw3/rdft/codelets/r2hc/r2hc_8.c @@ -0,0 +1,92 @@ +/* + * 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 21:56:41 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_r2hc -compact -variables 4 -n 8 -name r2hc_8 -include r2hc.h */ + +/* + * This function contains 20 FP additions, 2 FP multiplications, + * (or, 20 additions, 2 multiplications, 0 fused multiply/add), + * 14 stack variables, and 16 memory accesses + */ +/* + * Generator Id's : + * $Id: r2hc_8.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: r2hc_8.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: r2hc_8.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + */ + +#include "r2hc.h" + +static void r2hc_8(const R *I, R *ro, R *io, stride is, stride ros, stride ios, int v, int ivs, int ovs) +{ + DK(KP707106781, +0.707106781186547524400844362104849039284835938); + int i; + for (i = v; i > 0; i = i - 1, I = I + ivs, ro = ro + ovs, io = io + ovs) { + E T3, T7, Td, Tj, T6, Tg, Ta, Ti; + { + E T1, T2, Tb, Tc; + T1 = I[0]; + T2 = I[WS(is, 4)]; + T3 = T1 + T2; + T7 = T1 - T2; + Tb = I[WS(is, 7)]; + Tc = I[WS(is, 3)]; + Td = Tb - Tc; + Tj = Tb + Tc; + } + { + E T4, T5, T8, T9; + T4 = I[WS(is, 2)]; + T5 = I[WS(is, 6)]; + T6 = T4 + T5; + Tg = T4 - T5; + T8 = I[WS(is, 1)]; + T9 = I[WS(is, 5)]; + Ta = T8 - T9; + Ti = T8 + T9; + } + ro[WS(ros, 2)] = T3 - T6; + io[WS(ios, 2)] = Tj - Ti; + { + E Te, Tf, Th, Tk; + Te = KP707106781 * (Ta + Td); + ro[WS(ros, 3)] = T7 - Te; + ro[WS(ros, 1)] = T7 + Te; + Tf = KP707106781 * (Td - Ta); + io[WS(ios, 1)] = Tf - Tg; + io[WS(ios, 3)] = Tg + Tf; + Th = T3 + T6; + Tk = Ti + Tj; + ro[WS(ros, 4)] = Th - Tk; + ro[0] = Th + Tk; + } + } +} + +static const kr2hc_desc desc = { 8, "r2hc_8", {20, 2, 0, 0}, &GENUS, 0, 0, 0, 0, 0 }; + +void X(codelet_r2hc_8) (planner *p) { + X(kr2hc_register) (p, r2hc_8, &desc); +} diff --git a/src/fftw3/rdft/codelets/r2hc/r2hc_9.c b/src/fftw3/rdft/codelets/r2hc/r2hc_9.c new file mode 100644 index 0000000..df3808f --- /dev/null +++ b/src/fftw3/rdft/codelets/r2hc/r2hc_9.c @@ -0,0 +1,115 @@ +/* + * 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 21:56:40 EDT 2003 */ + +#include "codelet-rdft.h" + +/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_r2hc -compact -variables 4 -n 9 -name r2hc_9 -include r2hc.h */ + +/* + * This function contains 38 FP additions, 26 FP multiplications, + * (or, 21 additions, 9 multiplications, 17 fused multiply/add), + * 36 stack variables, and 18 memory accesses + */ +/* + * Generator Id's : + * $Id: r2hc_9.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: r2hc_9.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + * $Id: r2hc_9.c,v 1.1 2008/10/17 06:12:34 scuri Exp $ + */ + +#include "r2hc.h" + +static void r2hc_9(const R *I, R *ro, R *io, stride is, stride ros, stride ios, int v, int ivs, int ovs) +{ + DK(KP939692620, +0.939692620785908384054109277324731469936208134); + DK(KP296198132, +0.296198132726023843175338011893050938967728390); + DK(KP342020143, +0.342020143325668733044099614682259580763083368); + DK(KP813797681, +0.813797681349373692844693217248393223289101568); + DK(KP984807753, +0.984807753012208059366743024589523013670643252); + DK(KP150383733, +0.150383733180435296639271897612501926072238258); + DK(KP642787609, +0.642787609686539326322643409907263432907559884); + DK(KP663413948, +0.663413948168938396205421319635891297216863310); + DK(KP852868531, +0.852868531952443209628250963940074071936020296); + DK(KP173648177, +0.173648177666930348851716626769314796000375677); + DK(KP556670399, +0.556670399226419366452912952047023132968291906); + DK(KP766044443, +0.766044443118978035202392650555416673935832457); + DK(KP866025403, +0.866025403784438646763723170752936183471402627); + DK(KP500000000, +0.500000000000000000000000000000000000000000000); + int i; + for (i = v; i > 0; i = i - 1, I = I + ivs, ro = ro + ovs, io = io + ovs) { + E T1, T4, Tr, Ta, Tl, Ti, Tf, Tk, Tj, T2, T3, T5, Tg; + T1 = I[0]; + T2 = I[WS(is, 3)]; + T3 = I[WS(is, 6)]; + T4 = T2 + T3; + Tr = T3 - T2; + { + E T6, T7, T8, T9; + T6 = I[WS(is, 1)]; + T7 = I[WS(is, 4)]; + T8 = I[WS(is, 7)]; + T9 = T7 + T8; + Ta = T6 + T9; + Tl = T8 - T7; + Ti = FNMS(KP500000000, T9, T6); + } + { + E Tb, Tc, Td, Te; + Tb = I[WS(is, 2)]; + Tc = I[WS(is, 5)]; + Td = I[WS(is, 8)]; + Te = Tc + Td; + Tf = Tb + Te; + Tk = FNMS(KP500000000, Te, Tb); + Tj = Td - Tc; + } + io[WS(ios, 3)] = KP866025403 * (Tf - Ta); + T5 = T1 + T4; + Tg = Ta + Tf; + ro[WS(ros, 3)] = FNMS(KP500000000, Tg, T5); + ro[0] = T5 + Tg; + { + E Tt, Th, Tm, Tn, To, Tp, Tq, Ts; + Tt = KP866025403 * Tr; + Th = FNMS(KP500000000, T4, T1); + Tm = FMA(KP766044443, Ti, KP556670399 * Tl); + Tn = FMA(KP173648177, Tk, KP852868531 * Tj); + To = Tm + Tn; + Tp = FNMS(KP642787609, Ti, KP663413948 * Tl); + Tq = FNMS(KP984807753, Tk, KP150383733 * Tj); + Ts = Tp + Tq; + ro[WS(ros, 1)] = Th + To; + io[WS(ios, 1)] = Tt + Ts; + ro[WS(ros, 4)] = FMA(KP866025403, Tp - Tq, Th) - (KP500000000 * To); + io[WS(ios, 4)] = FNMS(KP500000000, Ts, KP866025403 * (Tr + (Tn - Tm))); + io[WS(ios, 2)] = FNMS(KP342020143, Tk, KP813797681 * Tj) + FNMA(KP150383733, Tl, KP984807753 * Ti) - Tt; + ro[WS(ros, 2)] = FMA(KP173648177, Ti, Th) + FNMA(KP296198132, Tj, KP939692620 * Tk) - (KP852868531 * Tl); + } + } +} + +static const kr2hc_desc desc = { 9, "r2hc_9", {21, 9, 17, 0}, &GENUS, 0, 0, 0, 0, 0 }; + +void X(codelet_r2hc_9) (planner *p) { + X(kr2hc_register) (p, r2hc_9, &desc); +} diff --git a/src/fftw3/rdft/codelets/r2hc/rhcodlist.c b/src/fftw3/rdft/codelets/r2hc/rhcodlist.c new file mode 100644 index 0000000..a4ac1bc --- /dev/null +++ b/src/fftw3/rdft/codelets/r2hc/rhcodlist.c @@ -0,0 +1,114 @@ +#include "ifftw.h" + +extern void X(codelet_r2hc_2)(planner *); +extern void X(codelet_r2hc_3)(planner *); +extern void X(codelet_r2hc_4)(planner *); +extern void X(codelet_r2hc_5)(planner *); +extern void X(codelet_r2hc_6)(planner *); +extern void X(codelet_r2hc_7)(planner *); +extern void X(codelet_r2hc_8)(planner *); +extern void X(codelet_r2hc_9)(planner *); +extern void X(codelet_r2hc_10)(planner *); +extern void X(codelet_r2hc_11)(planner *); +extern void X(codelet_r2hc_12)(planner *); +extern void X(codelet_r2hc_13)(planner *); +extern void X(codelet_r2hc_14)(planner *); +extern void X(codelet_r2hc_15)(planner *); +extern void X(codelet_r2hc_16)(planner *); +extern void X(codelet_r2hc_32)(planner *); +extern void X(codelet_mr2hc_32)(planner *); +extern void X(codelet_mr2hc_64)(planner *); +extern void X(codelet_mr2hc_128)(planner *); +extern void X(codelet_hf_2)(planner *); +extern void X(codelet_hf_3)(planner *); +extern void X(codelet_hf_4)(planner *); +extern void X(codelet_hf_5)(planner *); +extern void X(codelet_hf_6)(planner *); +extern void X(codelet_hf_7)(planner *); +extern void X(codelet_hf_8)(planner *); +extern void X(codelet_hf_9)(planner *); +extern void X(codelet_hf_10)(planner *); +extern void X(codelet_hf_12)(planner *); +extern void X(codelet_hf_15)(planner *); +extern void X(codelet_hf_16)(planner *); +extern void X(codelet_hf_32)(planner *); +extern void X(codelet_hf_64)(planner *); +extern void X(codelet_hf2_4)(planner *); +extern void X(codelet_hf2_8)(planner *); +extern void X(codelet_hf2_16)(planner *); +extern void X(codelet_hf2_32)(planner *); +extern void X(codelet_hf2_64)(planner *); +extern void X(codelet_r2hcII_2)(planner *); +extern void X(codelet_r2hcII_3)(planner *); +extern void X(codelet_r2hcII_4)(planner *); +extern void X(codelet_r2hcII_5)(planner *); +extern void X(codelet_r2hcII_6)(planner *); +extern void X(codelet_r2hcII_7)(planner *); +extern void X(codelet_r2hcII_8)(planner *); +extern void X(codelet_r2hcII_9)(planner *); +extern void X(codelet_r2hcII_10)(planner *); +extern void X(codelet_r2hcII_12)(planner *); +extern void X(codelet_r2hcII_15)(planner *); +extern void X(codelet_r2hcII_16)(planner *); +extern void X(codelet_r2hcII_32)(planner *); +extern void X(codelet_mr2hcII_32)(planner *); +extern void X(codelet_mr2hcII_64)(planner *); + + +extern const solvtab X(solvtab_rdft_r2hc); +const solvtab X(solvtab_rdft_r2hc) = { + SOLVTAB(X(codelet_r2hc_2)), + SOLVTAB(X(codelet_r2hc_3)), + SOLVTAB(X(codelet_r2hc_4)), + SOLVTAB(X(codelet_r2hc_5)), + SOLVTAB(X(codelet_r2hc_6)), + SOLVTAB(X(codelet_r2hc_7)), + SOLVTAB(X(codelet_r2hc_8)), + SOLVTAB(X(codelet_r2hc_9)), + SOLVTAB(X(codelet_r2hc_10)), + SOLVTAB(X(codelet_r2hc_11)), + SOLVTAB(X(codelet_r2hc_12)), + SOLVTAB(X(codelet_r2hc_13)), + SOLVTAB(X(codelet_r2hc_14)), + SOLVTAB(X(codelet_r2hc_15)), + SOLVTAB(X(codelet_r2hc_16)), + SOLVTAB(X(codelet_r2hc_32)), + SOLVTAB(X(codelet_mr2hc_32)), + SOLVTAB(X(codelet_mr2hc_64)), + SOLVTAB(X(codelet_mr2hc_128)), + SOLVTAB(X(codelet_hf_2)), + SOLVTAB(X(codelet_hf_3)), + SOLVTAB(X(codelet_hf_4)), + SOLVTAB(X(codelet_hf_5)), + SOLVTAB(X(codelet_hf_6)), + SOLVTAB(X(codelet_hf_7)), + SOLVTAB(X(codelet_hf_8)), + SOLVTAB(X(codelet_hf_9)), + SOLVTAB(X(codelet_hf_10)), + SOLVTAB(X(codelet_hf_12)), + SOLVTAB(X(codelet_hf_15)), + SOLVTAB(X(codelet_hf_16)), + SOLVTAB(X(codelet_hf_32)), + SOLVTAB(X(codelet_hf_64)), + SOLVTAB(X(codelet_hf2_4)), + SOLVTAB(X(codelet_hf2_8)), + SOLVTAB(X(codelet_hf2_16)), + SOLVTAB(X(codelet_hf2_32)), + SOLVTAB(X(codelet_hf2_64)), + SOLVTAB(X(codelet_r2hcII_2)), + SOLVTAB(X(codelet_r2hcII_3)), + SOLVTAB(X(codelet_r2hcII_4)), + SOLVTAB(X(codelet_r2hcII_5)), + SOLVTAB(X(codelet_r2hcII_6)), + SOLVTAB(X(codelet_r2hcII_7)), + SOLVTAB(X(codelet_r2hcII_8)), + SOLVTAB(X(codelet_r2hcII_9)), + SOLVTAB(X(codelet_r2hcII_10)), + SOLVTAB(X(codelet_r2hcII_12)), + SOLVTAB(X(codelet_r2hcII_15)), + SOLVTAB(X(codelet_r2hcII_16)), + SOLVTAB(X(codelet_r2hcII_32)), + SOLVTAB(X(codelet_mr2hcII_32)), + SOLVTAB(X(codelet_mr2hcII_64)), + SOLVTAB_END +}; |