cannam@167: /*
cannam@167: * Copyright (c) 2003, 2007-14 Matteo Frigo
cannam@167: * Copyright (c) 2003, 2007-14 Massachusetts Institute of Technology
cannam@167: *
cannam@167: * This program is free software; you can redistribute it and/or modify
cannam@167: * it under the terms of the GNU General Public License as published by
cannam@167: * the Free Software Foundation; either version 2 of the License, or
cannam@167: * (at your option) any later version.
cannam@167: *
cannam@167: * This program is distributed in the hope that it will be useful,
cannam@167: * but WITHOUT ANY WARRANTY; without even the implied warranty of
cannam@167: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
cannam@167: * GNU General Public License for more details.
cannam@167: *
cannam@167: * You should have received a copy of the GNU General Public License
cannam@167: * along with this program; if not, write to the Free Software
cannam@167: * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
cannam@167: *
cannam@167: */
cannam@167:
cannam@167:
cannam@167: #include "rdft/rdft.h"
cannam@167: #include <stddef.h>
cannam@167:
cannam@167: static void destroy(problem *ego_)
cannam@167: {
cannam@167: problem_rdft *ego = (problem_rdft *) ego_;
cannam@167: #if !defined(STRUCT_HACK_C99) && !defined(STRUCT_HACK_KR)
cannam@167: X(ifree0)(ego->kind);
cannam@167: #endif
cannam@167: X(tensor_destroy2)(ego->vecsz, ego->sz);
cannam@167: X(ifree)(ego_);
cannam@167: }
cannam@167:
cannam@167: static void kind_hash(md5 *m, const rdft_kind *kind, int rnk)
cannam@167: {
cannam@167: int i;
cannam@167: for (i = 0; i < rnk; ++i)
cannam@167: X(md5int)(m, kind[i]);
cannam@167: }
cannam@167:
cannam@167: static void hash(const problem *p_, md5 *m)
cannam@167: {
cannam@167: const problem_rdft *p = (const problem_rdft *) p_;
cannam@167: X(md5puts)(m, "rdft");
cannam@167: X(md5int)(m, p->I == p->O);
cannam@167: kind_hash(m, p->kind, p->sz->rnk);
cannam@167: X(md5int)(m, X(ialignment_of)(p->I));
cannam@167: X(md5int)(m, X(ialignment_of)(p->O));
cannam@167: X(tensor_md5)(m, p->sz);
cannam@167: X(tensor_md5)(m, p->vecsz);
cannam@167: }
cannam@167:
cannam@167: static void recur(const iodim *dims, int rnk, R *I)
cannam@167: {
cannam@167: if (rnk == RNK_MINFTY)
cannam@167: return;
cannam@167: else if (rnk == 0)
cannam@167: I[0] = K(0.0);
cannam@167: else if (rnk > 0) {
cannam@167: INT i, n = dims[0].n, is = dims[0].is;
cannam@167:
cannam@167: if (rnk == 1) {
cannam@167: /* this case is redundant but faster */
cannam@167: for (i = 0; i < n; ++i)
cannam@167: I[i * is] = K(0.0);
cannam@167: } else {
cannam@167: for (i = 0; i < n; ++i)
cannam@167: recur(dims + 1, rnk - 1, I + i * is);
cannam@167: }
cannam@167: }
cannam@167: }
cannam@167:
cannam@167: void X(rdft_zerotens)(tensor *sz, R *I)
cannam@167: {
cannam@167: recur(sz->dims, sz->rnk, I);
cannam@167: }
cannam@167:
cannam@167: #define KSTR_LEN 8
cannam@167:
cannam@167: const char *X(rdft_kind_str)(rdft_kind kind)
cannam@167: {
cannam@167: static const char kstr[][KSTR_LEN] = {
cannam@167: "r2hc", "r2hc01", "r2hc10", "r2hc11",
cannam@167: "hc2r", "hc2r01", "hc2r10", "hc2r11",
cannam@167: "dht",
cannam@167: "redft00", "redft01", "redft10", "redft11",
cannam@167: "rodft00", "rodft01", "rodft10", "rodft11"
cannam@167: };
cannam@167: A(kind >= 0 && kind < sizeof(kstr) / KSTR_LEN);
cannam@167: return kstr[kind];
cannam@167: }
cannam@167:
cannam@167: static void print(const problem *ego_, printer *p)
cannam@167: {
cannam@167: const problem_rdft *ego = (const problem_rdft *) ego_;
cannam@167: int i;
cannam@167: p->print(p, "(rdft %d %D %T %T",
cannam@167: X(ialignment_of)(ego->I),
cannam@167: (INT)(ego->O - ego->I),
cannam@167: ego->sz,
cannam@167: ego->vecsz);
cannam@167: for (i = 0; i < ego->sz->rnk; ++i)
cannam@167: p->print(p, " %d", (int)ego->kind[i]);
cannam@167: p->print(p, ")");
cannam@167: }
cannam@167:
cannam@167: static void zero(const problem *ego_)
cannam@167: {
cannam@167: const problem_rdft *ego = (const problem_rdft *) ego_;
cannam@167: tensor *sz = X(tensor_append)(ego->vecsz, ego->sz);
cannam@167: X(rdft_zerotens)(sz, UNTAINT(ego->I));
cannam@167: X(tensor_destroy)(sz);
cannam@167: }
cannam@167:
cannam@167: static const problem_adt padt =
cannam@167: {
cannam@167: PROBLEM_RDFT,
cannam@167: hash,
cannam@167: zero,
cannam@167: print,
cannam@167: destroy
cannam@167: };
cannam@167:
cannam@167: /* Dimensions of size 1 that are not REDFT/RODFT are no-ops and can be
cannam@167: eliminated. REDFT/RODFT unit dimensions often have factors of 2.0
cannam@167: and suchlike from normalization and phases, although in principle
cannam@167: these constant factors from different dimensions could be combined. */
cannam@167: static int nontrivial(const iodim *d, rdft_kind kind)
cannam@167: {
cannam@167: return (d->n > 1 || kind == R2HC11 || kind == HC2R11
cannam@167: || (REODFT_KINDP(kind) && kind != REDFT01 && kind != RODFT01));
cannam@167: }
cannam@167:
cannam@167: problem *X(mkproblem_rdft)(const tensor *sz, const tensor *vecsz,
cannam@167: R *I, R *O, const rdft_kind *kind)
cannam@167: {
cannam@167: problem_rdft *ego;
cannam@167: int rnk = sz->rnk;
cannam@167: int i;
cannam@167:
cannam@167: A(X(tensor_kosherp)(sz));
cannam@167: A(X(tensor_kosherp)(vecsz));
cannam@167: A(FINITE_RNK(sz->rnk));
cannam@167:
cannam@167: if (UNTAINT(I) == UNTAINT(O))
cannam@167: I = O = JOIN_TAINT(I, O);
cannam@167:
cannam@167: if (I == O && !X(tensor_inplace_locations)(sz, vecsz))
cannam@167: return X(mkproblem_unsolvable)();
cannam@167:
cannam@167: for (i = rnk = 0; i < sz->rnk; ++i) {
cannam@167: A(sz->dims[i].n > 0);
cannam@167: if (nontrivial(sz->dims + i, kind[i]))
cannam@167: ++rnk;
cannam@167: }
cannam@167:
cannam@167: #if defined(STRUCT_HACK_KR)
cannam@167: ego = (problem_rdft *) X(mkproblem)(sizeof(problem_rdft)
cannam@167: + sizeof(rdft_kind)
cannam@167: * (rnk > 0 ? rnk - 1u : 0u), &padt);
cannam@167: #elif defined(STRUCT_HACK_C99)
cannam@167: ego = (problem_rdft *) X(mkproblem)(sizeof(problem_rdft)
cannam@167: + sizeof(rdft_kind) * (unsigned)rnk, &padt);
cannam@167: #else
cannam@167: ego = (problem_rdft *) X(mkproblem)(sizeof(problem_rdft), &padt);
cannam@167: ego->kind = (rdft_kind *) MALLOC(sizeof(rdft_kind) * (unsigned)rnk, PROBLEMS);
cannam@167: #endif
cannam@167:
cannam@167: /* do compression and sorting as in X(tensor_compress), but take
cannam@167: transform kind into account (sigh) */
cannam@167: ego->sz = X(mktensor)(rnk);
cannam@167: for (i = rnk = 0; i < sz->rnk; ++i) {
cannam@167: if (nontrivial(sz->dims + i, kind[i])) {
cannam@167: ego->kind[rnk] = kind[i];
cannam@167: ego->sz->dims[rnk++] = sz->dims[i];
cannam@167: }
cannam@167: }
cannam@167: for (i = 0; i + 1 < rnk; ++i) {
cannam@167: int j;
cannam@167: for (j = i + 1; j < rnk; ++j)
cannam@167: if (X(dimcmp)(ego->sz->dims + i, ego->sz->dims + j) > 0) {
cannam@167: iodim dswap;
cannam@167: rdft_kind kswap;
cannam@167: dswap = ego->sz->dims[i];
cannam@167: ego->sz->dims[i] = ego->sz->dims[j];
cannam@167: ego->sz->dims[j] = dswap;
cannam@167: kswap = ego->kind[i];
cannam@167: ego->kind[i] = ego->kind[j];
cannam@167: ego->kind[j] = kswap;
cannam@167: }
cannam@167: }
cannam@167:
cannam@167: for (i = 0; i < rnk; ++i)
cannam@167: if (ego->sz->dims[i].n == 2 && (ego->kind[i] == REDFT00
cannam@167: || ego->kind[i] == DHT
cannam@167: || ego->kind[i] == HC2R))
cannam@167: ego->kind[i] = R2HC; /* size-2 transforms are equivalent */
cannam@167:
cannam@167: ego->vecsz = X(tensor_compress_contiguous)(vecsz);
cannam@167: ego->I = I;
cannam@167: ego->O = O;
cannam@167:
cannam@167: A(FINITE_RNK(ego->sz->rnk));
cannam@167:
cannam@167: return &(ego->super);
cannam@167: }
cannam@167:
cannam@167: /* Same as X(mkproblem_rdft), but also destroy input tensors. */
cannam@167: problem *X(mkproblem_rdft_d)(tensor *sz, tensor *vecsz,
cannam@167: R *I, R *O, const rdft_kind *kind)
cannam@167: {
cannam@167: problem *p = X(mkproblem_rdft)(sz, vecsz, I, O, kind);
cannam@167: X(tensor_destroy2)(vecsz, sz);
cannam@167: return p;
cannam@167: }
cannam@167:
cannam@167: /* As above, but for rnk <= 1 only and takes a scalar kind parameter */
cannam@167: problem *X(mkproblem_rdft_1)(const tensor *sz, const tensor *vecsz,
cannam@167: R *I, R *O, rdft_kind kind)
cannam@167: {
cannam@167: A(sz->rnk <= 1);
cannam@167: return X(mkproblem_rdft)(sz, vecsz, I, O, &kind);
cannam@167: }
cannam@167:
cannam@167: problem *X(mkproblem_rdft_1_d)(tensor *sz, tensor *vecsz,
cannam@167: R *I, R *O, rdft_kind kind)
cannam@167: {
cannam@167: A(sz->rnk <= 1);
cannam@167: return X(mkproblem_rdft_d)(sz, vecsz, I, O, &kind);
cannam@167: }
cannam@167:
cannam@167: /* create a zero-dimensional problem */
cannam@167: problem *X(mkproblem_rdft_0_d)(tensor *vecsz, R *I, R *O)
cannam@167: {
cannam@167: return X(mkproblem_rdft_d)(X(mktensor_0d)(), vecsz, I, O,
cannam@167: (const rdft_kind *)0);
cannam@167: }