C++ (Cpp) DFTPの例

コード例 #1

ファイル: ct.c プロジェクト: OS2World/MM-SOUND-PM123

int X(dft_ct_applicable)(const solver_ct *ego, const problem *p_)
{
     if (DFTP(p_)) {
          const problem_dft *p = (const problem_dft *) p_;
          const ct_desc *d = ego->desc;
          return (   p->sz->rnk == 1
                  && p->vecsz->rnk <= 1
                  && divides(d->radix, p->sz->dims[0].n)
	       );
     }
     return 0;
}

コード例 #2

ファイル: dft-r2hc.c プロジェクト: abrahamneben/orbcomm_beam_mapping

static int applicable0(const problem *p_)
{
     if (DFTP(p_)) {
          const problem_dft *p = (const problem_dft *) p_;
          return ((p->sz->rnk == 1 && p->vecsz->rnk == 0)
#if ALLOW_RANK0
		  || p->sz->rnk == 0
#endif
	       );
     }

     return 0;
}

コード例 #3

ファイル: rank0.c プロジェクト: abrahamneben/orbcomm_beam_mapping

/* generic applicability function */
static int applicable(const solver *ego_, const problem *p_)
{
     if (DFTP(p_)) {
          const S *ego = (const S *) ego_;
          const problem_dft *p = (const problem_dft *) p_;
          return (1
		  && p->ri != p->ro
                  && p->sz->rnk == 0
                  && ego->adt->applicable(p)
	       );
     }
     return 0;
}

コード例 #4

ファイル: rank_geq2.c プロジェクト: OS2World/MM-SOUND-PM123

static int applicable0(const solver *ego_, const problem *p_, int *rp)
{
     if (DFTP(p_)) {
          const problem_dft *p = (const problem_dft *) p_;
          const S *ego = (const S *)ego_;
          return (
                     p->sz->rnk >= 2
                  && picksplit(ego, p->sz, rp)
	       );
     }

     return 0;
}

コード例 #5

ファイル: rader.c プロジェクト: OS2World/MM-SOUND-PM123

static int applicable0_dit(const solver *ego_, const problem *p_)
{
     UNUSED(ego_);
     if (DFTP(p_)) {
          const problem_dft *p = (const problem_dft *) p_;
          return (
	          p->sz->rnk == 1
	       && p->vecsz->rnk == 0
	       && p->sz->dims[0].n > 1
	       );
     }

     return 0;
}

コード例 #6

ファイル: vrank-geq1.c プロジェクト: abrahamneben/orbcomm_beam_mapping

static int applicable0(const solver *ego_, const problem *p_, int *dp)
{
     if (DFTP(p_)) {
          const S *ego = (const S *) ego_;
          const problem_dft *p = (const problem_dft *) p_;

          return (1
                  && FINITE_RNK(p->vecsz->rnk)
                  && p->vecsz->rnk > 0
                  && pickdim(ego, p->vecsz, p->ri != p->ro, dp)
	       );
     }

     return 0;
}

コード例 #7

ファイル: vrank2-transpose.c プロジェクト: abrahamneben/orbcomm_beam_mapping

static int applicable(const problem *p_, const planner *plnr)
{
     if (DFTP(p_)) {
          const problem_dft *p = (const problem_dft *)p_;
	  const iodim *d = p->vecsz->dims;
          return (1
                  && p->ri == p->ro
                  && p->sz->rnk == 0
                  && p->vecsz->rnk == 2
		  && X(transposable)(d, d+1, 1, X(imin)(d[0].is,d[0].os),
				     p->ri, p->ii)
		  && (!NO_UGLYP(plnr) || d[0].n == d[1].n)
	       );
     }
     return 0;
}

コード例 #8

ファイル: direct.c プロジェクト: OS2World/MM-SOUND-PM123

static int applicable(const solver *ego_, const problem *p_,
		      const planner *plnr)
{
     if (DFTP(p_)) {
          const S *ego = (const S *) ego_;
          const problem_dft *p = (const problem_dft *) p_;
          const kdft_desc *d = ego->desc;
	  int vl;
	  int ivs, ovs;

          return (
	          p->sz->rnk == 1
	       && p->vecsz->rnk <= 1
	       && p->sz->dims[0].n == d->sz

	       /* check strides etc */
	       && X(tensor_tornk1)(p->vecsz, &vl, &ivs, &ovs)

	       && (d->genus->okp(d, p->ri, p->ii, p->ro, p->io,
				 p->sz->dims[0].is, p->sz->dims[0].os,
				 vl, ivs, ovs, plnr))

	       && (/* can operate out-of-place */
		   p->ri != p->ro

		   /*
		    * can compute one transform in-place, no matter
		    * what the strides are.
		    */
		   || p->vecsz->rnk == 0

		   /* can operate in-place as long as strides are the same */
		   || (X(tensor_inplace_strides2)(p->sz, p->vecsz))
		    )
	       );
     }

     return 0;
}