static solver *mksolver(const ndrct_adt *adt)
{
static const solver_adt sadt = { PROBLEM_RDFT, mkplan, 0 };
S *slv = MKSOLVER(S, &sadt);
slv->adt = adt;
return &(slv->super);
}
static solver *mksolver(int pad)
{
static const solver_adt sadt = { PROBLEM_RDFT, mkplan, 0 };
S *slv = MKSOLVER(S, &sadt);
slv->pad = pad;
return &(slv->super);
}
static solver *mksolver(int preserve_input)
{
static const solver_adt sadt = { PROBLEM_MPI_RDFT2, mkplan, 0 };
S *slv = MKSOLVER(S, &sadt);
slv->preserve_input = preserve_input;
return &(slv->super);
}
static solver *mksolver(const rnk0adt *adt)
{
static const solver_adt sadt = { mkplan };
S *slv = MKSOLVER(S, &sadt);
slv->adt = adt;
return &(slv->super);
}
static solver *mksolver(int copy_transposed_in)
{
static const solver_adt sadt = { PROBLEM_MPI_TRANSPOSE, mkplan, 0 };
S *slv = MKSOLVER(S, &sadt);
slv->copy_transposed_in = copy_transposed_in;
return &(slv->super);
}
static solver *mksolver(int maxnbuf_ndx)
{
static const solver_adt sadt = { PROBLEM_RDFT, mkplan, 0 };
S *slv = MKSOLVER(S, &sadt);
slv->maxnbuf_ndx = maxnbuf_ndx;
return &(slv->super);
}
/* constructor */
solver *X(mksolver_dft_direct)(kdft k, const kdft_desc *desc)
{
static const solver_adt sadt = { mkplan };
S *slv = MKSOLVER(S, &sadt);
slv->k = k;
slv->desc = desc;
return &(slv->super);
}
static solver *mksolver(rearrangement rearrange, int preserve_input)
{
static const solver_adt sadt = { PROBLEM_MPI_RDFT, mkplan, 0 };
S *slv = MKSOLVER(S, &sadt);
slv->rearrange = rearrange;
slv->preserve_input = preserve_input;
return &(slv->super);
}
/* constructor */
solver *fftwf_mksolver_rdft_r2r_direct(kr2r k, const kr2r_desc *desc)
{
static const solver_adt sadt = { PROBLEM_RDFT, mkplan, 0 };
S *slv = MKSOLVER(S, &sadt);
slv->k = k;
slv->desc = desc;
return &(slv->super);
}
static solver *mksolver(kdft k, const kdft_desc *desc, int bufferedp)
{
static const solver_adt sadt = { PROBLEM_DFT, mkplan, 0 };
S *slv = MKSOLVER(S, &sadt);
slv->k = k;
slv->desc = desc;
slv->bufferedp = bufferedp;
return &(slv->super);
}
static solver *mksolver(int spltrnk, const int *buddies, int nbuddies)
{
static const solver_adt sadt = { PROBLEM_RDFT, mkplan, 0 };
S *slv = MKSOLVER(S, &sadt);
slv->spltrnk = spltrnk;
slv->buddies = buddies;
slv->nbuddies = nbuddies;
return &(slv->super);
}
static solver *mksolver(int vecloop_dim, const int *buddies, size_t nbuddies)
{
static const solver_adt sadt = { PROBLEM_DFT, mkplan, 0 };
S *slv = MKSOLVER(S, &sadt);
slv->vecloop_dim = vecloop_dim;
slv->buddies = buddies;
slv->nbuddies = nbuddies;
return &(slv->super);
}
static solver *mksolver(int preserve_input,
int (*radix)(int np), const char *nam)
{
static const solver_adt sadt = { PROBLEM_MPI_TRANSPOSE, mkplan, 0 };
S *slv = MKSOLVER(S, &sadt);
slv->preserve_input = preserve_input;
slv->radix = radix;
slv->nam = nam;
return &(slv->super);
}
solver *X(mksolver_dft_ct)(union kct k, const ct_desc *desc,
const char *nam, const solver_adt *adt)
{
solver_ct *slv;
slv = MKSOLVER(solver_ct, adt);
slv->desc = desc;
slv->k = k;
slv->nam = nam;
return &(slv->super);
}
void X(rdft_rank0_register)(planner *p)
{
unsigned i;
static struct {
rdftapply apply;
int (*applicable)(const P *, const problem_rdft *);
const char *nam;
} tab[] = {
{ apply_memcpy, applicable_memcpy, "rdft-rank0-memcpy" },
{ apply_memcpy_loop, applicable_memcpy_loop,
"rdft-rank0-memcpy-loop" },
{ apply_iter, applicable_iter, "rdft-rank0-iter-ci" },
{ apply_cpy2dco, applicable_cpy2dco, "rdft-rank0-iter-co" },
{ apply_tiled, applicable_tiled, "rdft-rank0-tiled" },
{ apply_tiledbuf, applicable_tiledbuf, "rdft-rank0-tiledbuf" },
{ apply_ip_sq, applicable_ip_sq, "rdft-rank0-ip-sq" },
#if HAVE_CELL
{ apply_cell, applicable_cell, "rdft-rank0-cell" },
{ apply_ip_cell, applicable_ip_cell, "rdft-rank0-ip-cell" },
#endif
{
apply_ip_sq_tiled,
applicable_ip_sq_tiled,
"rdft-rank0-ip-sq-tiled"
},
{
apply_ip_sq_tiledbuf,
applicable_ip_sq_tiledbuf,
"rdft-rank0-ip-sq-tiledbuf"
},
};
for (i = 0; i < sizeof(tab) / sizeof(tab[0]); ++i) {
static const solver_adt sadt = { PROBLEM_RDFT, mkplan, 0 };
S *slv = MKSOLVER(S, &sadt);
slv->apply = tab[i].apply;
slv->applicable = tab[i].applicable;
slv->nam = tab[i].nam;
REGISTER_SOLVER(p, &(slv->super));
}
}
/* constructor */
static solver *mksolver(void)
{
static const solver_adt sadt = { mkplan };
S *slv = MKSOLVER(S, &sadt);
return &(slv->super);
}
static solver *mksolver(void)
{
static const solver_adt sadt = { PROBLEM_DFT, mkplan, 0 };
return MKSOLVER(solver, &sadt);
}
static solver *mksolver(void)
{
static const solver_adt sadt = { mkplan };
return MKSOLVER(solver, &sadt);
}
/* constructor */
static solver *mksolver(void)
{
static const solver_adt sadt = { PROBLEM_DFT, mkplan, 0 };
S *slv = MKSOLVER(S, &sadt);
return &(slv->super);
}