/*

 * Copyright (c) 2003, 2007-14 Matteo Frigo

 * Copyright (c) 2003, 2007-14 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

 *

 */

#include "api/api.h"

#include <math.h>

/* a flag operation: x is either a flag, in which case xm == 0, or

   a mask, in which case xm == x; using this we can compactly code

   the various bit operations via (flags & x) ^ xm or (flags | x) ^ xm. */

typedef struct {

     unsigned x, xm;

} flagmask;

typedef struct {

     flagmask flag;

     flagmask op;

} flagop;

#define FLAGP(f, msk)(((f) & (msk).x) ^ (msk).xm)

#define OP(f, msk)(((f) | (msk).x) ^ (msk).xm)

#define YES(x) {x, 0}

#define NO(x) {x, x}

#define IMPLIES(predicate, consequence) { predicate, consequence }

#define EQV(a, b) IMPLIES(YES(a), YES(b)), IMPLIES(NO(a), NO(b))

#define NEQV(a, b) IMPLIES(YES(a), NO(b)), IMPLIES(NO(a), YES(b))

static void map_flags(unsigned *iflags, unsigned *oflags,

          const flagop flagmap[], size_t nmap)

{

     size_t i;

     for (i = 0; i < nmap; ++i)

          if (FLAGP(*iflags, flagmap[i].flag))

               *oflags = OP(*oflags, flagmap[i].op);

}

/* encoding of the planner timelimit into a BITS_FOR_TIMELIMIT-bits

   nonnegative integer, such that we can still view the integer as

   ``impatience'': higher means *lower* time limit, and 0 is the

   highest possible value (about 1 year of calendar time) */

static unsigned timelimit_to_flags(double timelimit)

{

     const double tmax = 365 * 24 * 3600;

     const double tstep = 1.05;

     const int nsteps = (1 << BITS_FOR_TIMELIMIT);

     int x;

     if (timelimit < 0 || timelimit >= tmax)

    return 0;

     if (timelimit <= 1.0e-10)

    return nsteps - 1;

     x = (int) (0.5 + (log(tmax / timelimit) / log(tstep)));

     if (x < 0) x = 0;

     if (x >= nsteps) x = nsteps - 1;

     return x;

}

void X(mapflags)(planner *plnr, unsigned flags)

{

     unsigned l, u, t;

     /* map of api flags -> api flags, to implement consistency rules

        and combination flags */

     const flagop self_flagmap[] = {

    /* in some cases (notably for halfcomplex->real transforms),

       DESTROY_INPUT is the default, so we need to support

       an inverse flag to disable it.

       (PRESERVE, DESTROY)   ->   (PRESERVE, DESTROY)

               (0, 0)                       (1, 0)

               (0, 1)                       (0, 1)

               (1, 0)                       (1, 0)

               (1, 1)                       (1, 0)

    */

    IMPLIES(YES(FFTW_PRESERVE_INPUT), NO(FFTW_DESTROY_INPUT)),

    IMPLIES(NO(FFTW_DESTROY_INPUT), YES(FFTW_PRESERVE_INPUT)),

    IMPLIES(YES(FFTW_EXHAUSTIVE), YES(FFTW_PATIENT)),

    IMPLIES(YES(FFTW_ESTIMATE), NO(FFTW_PATIENT)),

    IMPLIES(YES(FFTW_ESTIMATE),

      YES(FFTW_ESTIMATE_PATIENT 

          | FFTW_NO_INDIRECT_OP

          | FFTW_ALLOW_PRUNING)),

    IMPLIES(NO(FFTW_EXHAUSTIVE), 

      YES(FFTW_NO_SLOW)),

    /* a canonical set of fftw2-like impatience flags */

    IMPLIES(NO(FFTW_PATIENT),

      YES(FFTW_NO_VRECURSE

          | FFTW_NO_RANK_SPLITS

          | FFTW_NO_VRANK_SPLITS

          | FFTW_NO_NONTHREADED

          | FFTW_NO_DFT_R2HC

          | FFTW_NO_FIXED_RADIX_LARGE_N

          | FFTW_BELIEVE_PCOST))

     };

     /* map of (processed) api flags to internal problem/planner flags */

     const flagop l_flagmap[] = {

    EQV(FFTW_PRESERVE_INPUT, NO_DESTROY_INPUT),

    EQV(FFTW_NO_SIMD, NO_SIMD),

    EQV(FFTW_CONSERVE_MEMORY, CONSERVE_MEMORY),

    EQV(FFTW_NO_BUFFERING, NO_BUFFERING),

    NEQV(FFTW_ALLOW_LARGE_GENERIC, NO_LARGE_GENERIC)

     };

     const flagop u_flagmap[] = {

    IMPLIES(YES(FFTW_EXHAUSTIVE), NO(0xFFFFFFFF)),

    IMPLIES(NO(FFTW_EXHAUSTIVE), YES(NO_UGLY)),

    /* the following are undocumented, "beyond-guru" flags that

       require some understanding of FFTW internals */

    EQV(FFTW_ESTIMATE_PATIENT, ESTIMATE),

    EQV(FFTW_ALLOW_PRUNING, ALLOW_PRUNING),

    EQV(FFTW_BELIEVE_PCOST, BELIEVE_PCOST),

    EQV(FFTW_NO_DFT_R2HC, NO_DFT_R2HC),

    EQV(FFTW_NO_NONTHREADED, NO_NONTHREADED),

    EQV(FFTW_NO_INDIRECT_OP, NO_INDIRECT_OP),

    EQV(FFTW_NO_RANK_SPLITS, NO_RANK_SPLITS),

    EQV(FFTW_NO_VRANK_SPLITS, NO_VRANK_SPLITS),

    EQV(FFTW_NO_VRECURSE, NO_VRECURSE),

    EQV(FFTW_NO_SLOW, NO_SLOW),

    EQV(FFTW_NO_FIXED_RADIX_LARGE_N, NO_FIXED_RADIX_LARGE_N)

     };

     map_flags(&flags, &flags, self_flagmap, NELEM(self_flagmap));

     l = u = 0;

     map_flags(&flags, &l, l_flagmap, NELEM(l_flagmap));

     map_flags(&flags, &u, u_flagmap, NELEM(u_flagmap));

     /* enforce l <= u  */

     PLNR_L(plnr) = l;

     PLNR_U(plnr) = u | l;

     /* assert that the conversion didn't lose bits */

     A(PLNR_L(plnr) == l);

     A(PLNR_U(plnr) == (u | l));

     /* compute flags representation of the timelimit */

     t = timelimit_to_flags(plnr->timelimit);

     PLNR_TIMELIMIT_IMPATIENCE(plnr) = t;

     A(PLNR_TIMELIMIT_IMPATIENCE(plnr) == t);

}