static plan *mkcldw(const hc2hc_solver *ego_,
rdft_kind kind, INT r, INT m, INT s, INT vl, INT vs,
INT mstart, INT mcount,
R *IO, planner *plnr)
{
const S *ego = (const S *) ego_;
P *pln;
const hc2hc_desc *e = ego->desc;
plan *cld0, *cldm;
INT mstart1, mcount2;
static const plan_adt padt = {
0, awake, print, destroy
};
mstart1 = mstart + (mstart == 0);
mcount2 = 1 + 2 * (mcount - (mstart==0)
- (m%2 == 0 && mstart+mcount == (m+2)/2));
if (!applicable(ego, kind, r, m, s, vl, vs, mstart1, mcount2, IO, plnr))
return (plan *)0;
if (!X(hc2hc_mkcldrn)(kind, r, m, s, mstart, mcount,
IO, plnr, &cld0, &cldm))
return (plan *)0;
pln = MKPLAN_HC2HC(P, &padt, apply);
pln->k = ego->k;
pln->ios = X(mkstride)(r, m * s);
pln->td = 0;
pln->tdW = 0;
pln->r = r;
pln->m = m;
pln->s = s;
pln->vl = vl;
pln->vs = vs;
pln->slv = ego;
pln->cld0 = cld0;
pln->cldm = cldm;
pln->mstart1 = mstart1;
pln->mcount2 = mcount2;
X(ops_zero)(&pln->super.super.ops);
X(ops_madd2)(vl * (((mcount2 - 1) / 2) / e->genus->vl),
&e->ops, &pln->super.super.ops);
X(ops_madd2)(vl, &cld0->ops, &pln->super.super.ops);
X(ops_madd2)(vl, &cldm->ops, &pln->super.super.ops);
pln->super.super.could_prune_now_p = (r >= 5 && r < 64 && m >= r);
return &(pln->super.super);
}
static plan *mkcldw(const hc2hc_solver *ego_,
rdft_kind kind, INT r, INT m, INT ms, INT v, INT vs,
INT mstart, INT mcount,
R *IO, planner *plnr)
{
const S *ego = (const S *) ego_;
P *pln;
const hc2hc_desc *e = ego->desc;
plan *cld0 = 0, *cldm = 0;
INT imid = (m / 2) * ms;
INT rs = m * ms;
static const plan_adt padt = {
0, awake, print, destroy
};
if (!applicable(ego, kind, r, m, v, plnr))
return (plan *)0;
cld0 = X(mkplan_d)(
plnr,
X(mkproblem_rdft_1_d)((CLD0P(mstart) ?
X(mktensor_1d)(r, rs, rs) : X(mktensor_0d)()),
X(mktensor_0d)(),
TAINT(IO, vs), TAINT(IO, vs),
kind));
if (!cld0) goto nada;
cldm = X(mkplan_d)(
plnr,
X(mkproblem_rdft_1_d)((CLDMP(m, mstart, mcount) ?
X(mktensor_1d)(r, rs, rs) : X(mktensor_0d)()),
X(mktensor_0d)(),
TAINT(IO + imid, vs), TAINT(IO + imid, vs),
kind == R2HC ? R2HCII : HC2RIII));
if (!cldm) goto nada;
pln = MKPLAN_HC2HC(P, &padt, ego->bufferedp ? apply_buf : apply);
pln->k = ego->k;
pln->td = 0;
pln->r = r; pln->rs = X(mkstride)(r, rs);
pln->m = m; pln->ms = ms;
pln->v = v; pln->vs = vs;
pln->slv = ego;
pln->brs = X(mkstride)(r, 2 * compute_batchsize(r));
pln->cld0 = cld0;
pln->cldm = cldm;
pln->mb = mstart + CLD0P(mstart);
pln->me = mstart + mcount - CLDMP(m, mstart, mcount);
X(ops_zero)(&pln->super.super.ops);
X(ops_madd2)(v * ((pln->me - pln->mb) / e->genus->vl),
&e->ops, &pln->super.super.ops);
X(ops_madd2)(v, &cld0->ops, &pln->super.super.ops);
X(ops_madd2)(v, &cldm->ops, &pln->super.super.ops);
if (ego->bufferedp)
pln->super.super.ops.other += 4 * r * (pln->me - pln->mb) * v;
pln->super.super.could_prune_now_p =
(!ego->bufferedp && r >= 5 && r < 64 && m >= r);
return &(pln->super.super);
nada:
X(plan_destroy_internal)(cld0);
X(plan_destroy_internal)(cldm);
return 0;
}
static plan *mkcldw(const hc2hc_solver *ego_,
rdft_kind kind, INT r, INT m, INT s, INT vl, INT vs,
INT mstart, INT mcount,
R *IO, planner *plnr)
{
P *pln;
plan *cld0 = 0, *cld = 0;
INT mstart1, mcount1, mstride;
static const plan_adt padt = {
0, awake, print, destroy
};
UNUSED(ego_);
A(mstart >= 0 && mcount > 0 && mstart + mcount <= (m+2)/2);
if (!applicable(kind, r, m, plnr))
return (plan *)0;
A(m % 2);
mstart1 = mstart + (mstart == 0);
mcount1 = mcount - (mstart == 0);
mstride = m - (mstart + mcount - 1) - mstart1;
/* 0th (DC) transform (vl of these), if mstart == 0 */
cld0 = X(mkplan_d)(plnr,
X(mkproblem_rdft_1_d)(
mstart == 0 ? X(mktensor_1d)(r, m * s, m * s)
: X(mktensor_0d)(),
X(mktensor_1d)(vl, vs, vs),
IO, IO, kind)
);
if (!cld0) goto nada;
/* twiddle transforms: there are 2 x mcount1 x vl of these
(where 2 corresponds to the real and imaginary parts) ...
the 2 x mcount1 loops are combined if mstart=0 and mcount=(m+2)/2. */
cld = X(mkplan_d)(plnr,
X(mkproblem_rdft_1_d)(
X(mktensor_1d)(r, m * s, m * s),
X(mktensor_3d)(2, mstride * s, mstride * s,
mcount1, s, s,
vl, vs, vs),
IO + s * mstart1, IO + s * mstart1, kind)
);
if (!cld) goto nada;
pln = MKPLAN_HC2HC(P, &padt, (kind == R2HC) ? apply_dit : apply_dif);
pln->cld = cld;
pln->cld0 = cld0;
pln->r = r;
pln->m = m;
pln->s = s;
pln->vl = vl;
pln->vs = vs;
pln->td = 0;
pln->mstart1 = mstart1;
pln->mcount1 = mcount1;
{
double n0 = 0.5 * (r - 1) * (2 * mcount1) * vl;
pln->super.super.ops = cld->ops;
pln->super.super.ops.mul += (kind == R2HC ? 5.0 : 7.0) * n0;
pln->super.super.ops.add += 4.0 * n0;
pln->super.super.ops.other += 11.0 * n0;
}
return &(pln->super.super);
nada:
X(plan_destroy_internal)(cld);
X(plan_destroy_internal)(cld0);
return (plan *) 0;
}
