p_Procs_Impl.h File Reference

#include "misc/auxiliary.h"

Go to the source code of this file.

Macros
#define	HAVE_FAST_P_PROCS   0
#define	HAVE_FAST_FIELD   0
#define	HAVE_FAST_LENGTH   0
#define	HAVE_FAST_ORD   0
#define	HAVE_FAST_ZERO_ORD   0
#define	HAVE_LENGTH_DIFF
#define	ZP_COPY_FIELD(field)
#define	ORD_MAX_N_1   OrdNomog
#define	ORD_MAX_N_2   OrdPomogNeg
#define	ORD_MAX_N_3   OrdNegPosNomog
#define	SetProc(what, field, length, ord)
#define	SetProcs(field, length, ord)
#define	SetProcs_ring(field, length, ord)

Enumerations
enum	p_Field {   FieldGeneral = 0 , FieldZp , FieldQ , FieldR ,   FieldGF , FieldLong_R , FieldLong_C , FieldZp_a ,   FieldQ_a , RingGeneral , FieldUnknown }
enum	p_Length {   LengthGeneral = 0 , LengthEight , LengthSeven , LengthSix ,   LengthFive , LengthFour , LengthThree , LengthTwo ,   LengthOne , LengthUnknown }
enum	p_Ord {   OrdGeneral = 0 , OrdPomog , OrdNomog , OrdPomogZero ,   OrdNomogZero , OrdNegPomog , OrdPomogNeg , OrdPosNomog ,   OrdNomogPos , OrdNegPomogZero , OrdPomogNegZero , OrdPosPosNomog ,   OrdPosNomogPos , OrdNegPosNomog , OrdNomogPosZero , OrdPosNomogZero ,   OrdPosPosNomogZero , OrdPosNomogPosZero , OrdNegPosNomogZero , OrdUnknown }
enum	p_Proc {   p_Copy_Proc = 0 , p_Delete_Proc , p_ShallowCopyDelete_Proc , p_Mult_nn_Proc ,   pp_Mult_nn_Proc , pp_Mult_mm_Proc , pp_Mult_mm_Noether_Proc , p_Mult_mm_Proc ,   p_Add_q_Proc , p_Minus_mm_Mult_qq_Proc , p_Neg_Proc , pp_Mult_Coeff_mm_DivSelect_Proc ,   pp_Mult_Coeff_mm_DivSelectMult_Proc , p_Merge_q_Proc , p_kBucketSetLm_Proc , p_Unknown_Proc }

Functions
static const char *	p_FieldEnum_2_String (p_Field field)
static const char *	p_LengthEnum_2_String (p_Length length)
static const char *	p_OrdEnum_2_String (p_Ord ord)
static const char *	p_ProcEnum_2_String (p_Proc proc)
static int	p_ProcDependsOn_Field (p_Proc proc)
static int	p_ProcDependsOn_Ord (p_Proc proc)
static int	p_ProcDependsOn_Length (p_Proc proc)
static const char *	p_ProcField_2_Module (p_Proc proc, p_Field field)
static int	IsZeroOrd (p_Ord ord)
static p_Ord	ZeroOrd_2_NonZeroOrd (p_Ord ord, int strict)
static void	FastP_ProcsFilter (p_Field &field, p_Length &length, p_Ord &ord, const p_Proc proc)
static void	FastFieldFilter (p_Field &field)
static void	FastLengthFilter (p_Length &length)
static void	FastOrdFilter (p_Ord &ord)
static void	FastOrdZeroFilter (p_Ord &ord)
static void	NCopy__Filter (p_Field &field)
static void	p_Add_q__Filter (p_Field &field, p_Length &length, p_Ord &ord)
static void	p_Neg__Filter (p_Field &field, p_Length &length, p_Ord &ord)
static void	pp_Mult_mm_Noether_Filter (p_Field &field, p_Length &length, p_Ord &ord)
static void	FastProcFilter (p_Proc proc, p_Field &field, p_Length &length, p_Ord &ord)
static int	IsValidSpec (p_Field field, p_Length length, p_Ord ord)
static int	index (p_Length length, p_Ord ord)
static int	index (p_Field field, p_Length length)
static int	index (p_Field field, p_Length length, p_Ord ord)
static int	index (p_Proc proc, p_Field field, p_Length length, p_Ord ord)

Macro Definition Documentation

HAVE_FAST_FIELD

#define HAVE_FAST_FIELD   0

Definition at line 56 of file p_Procs_Impl.h.

HAVE_FAST_LENGTH

#define HAVE_FAST_LENGTH   0

Definition at line 66 of file p_Procs_Impl.h.

HAVE_FAST_ORD

#define HAVE_FAST_ORD   0

Definition at line 76 of file p_Procs_Impl.h.

HAVE_FAST_P_PROCS

#define HAVE_FAST_P_PROCS   0

Definition at line 47 of file p_Procs_Impl.h.

HAVE_FAST_ZERO_ORD

#define HAVE_FAST_ZERO_ORD   0

Definition at line 84 of file p_Procs_Impl.h.

HAVE_LENGTH_DIFF

#define HAVE_LENGTH_DIFF

Definition at line 88 of file p_Procs_Impl.h.

ORD_MAX_N_1

#define ORD_MAX_N_1   OrdNomog

Definition at line 142 of file p_Procs_Impl.h.

ORD_MAX_N_2

#define ORD_MAX_N_2   OrdPomogNeg

Definition at line 151 of file p_Procs_Impl.h.

ORD_MAX_N_3

#define ORD_MAX_N_3   OrdNegPosNomog

Definition at line 164 of file p_Procs_Impl.h.

SetProc

#define SetProc	(		what,
			field,
			length,
			ord )

Value:

do                                                          \
{                                                           \
  p_Field t_field = field;                                  \
  p_Ord t_ord = ord;                                        \
  p_Length t_length = length;                               \
  FastProcFilter(what##_Proc, t_field, t_length, t_ord);    \
  DoSetProc(what, t_field, t_length, t_ord);                \
}                                                           \
while (0)                                                   \

Definition at line 651 of file p_Procs_Impl.h.

#define SetProc(what, field, length, ord)                   \
do                                                          \
{                                                           \
  p_Field t_field = field;                                  \
  p_Ord t_ord = ord;                                        \
  p_Length t_length = length;                               \
  FastProcFilter(what##_Proc, t_field, t_length, t_ord);    \
  DoSetProc(what, t_field, t_length, t_ord);                \
}                                                           \
while (0)                                                   \
 

SetProcs

#define SetProcs	(		field,
			length,
			ord )

Value:

do                                                                      \
{                                                                       \
  SetProc(p_Copy, field, length, OrdGeneral);                           \
  SetProc(p_Delete, field, LengthGeneral, OrdGeneral);                  \
  SetProc(p_ShallowCopyDelete, FieldGeneral, length, OrdGeneral);       \
  SetProc(p_Mult_nn, field, LengthGeneral, OrdGeneral);                 \
  SetProc(pp_Mult_nn, field, length, OrdGeneral);                       \
  SetProc(pp_Mult_mm, field, length, OrdGeneral);                       \
  SetProc(p_Mult_mm, field, length, OrdGeneral);                        \
  SetProc(p_Minus_mm_Mult_qq, field, length, ord);                      \
  SetProc(pp_Mult_mm_Noether, field, length, ord);                      \
  SetProc(p_Add_q, field, length, ord);                                 \
  SetProc(p_Neg, field, LengthGeneral, OrdGeneral);                     \
  SetProc(pp_Mult_Coeff_mm_DivSelect, field, length, OrdGeneral);       \
  SetProc(pp_Mult_Coeff_mm_DivSelectMult, field, length, OrdGeneral);   \
  SetProc(p_Merge_q, FieldGeneral, length, ord);                        \
  SetProc(p_kBucketSetLm, field, length, ord);                          \
}                                                                       \
while (0)

Definition at line 662 of file p_Procs_Impl.h.

#define SetProcs(field, length, ord)                                    \
do                                                                      \
{                                                                       \
  SetProc(p_Copy, field, length, OrdGeneral);                           \
  SetProc(p_Delete, field, LengthGeneral, OrdGeneral);                  \
  SetProc(p_ShallowCopyDelete, FieldGeneral, length, OrdGeneral);       \
  SetProc(p_Mult_nn, field, LengthGeneral, OrdGeneral);                 \
  SetProc(pp_Mult_nn, field, length, OrdGeneral);                       \
  SetProc(pp_Mult_mm, field, length, OrdGeneral);                       \
  SetProc(p_Mult_mm, field, length, OrdGeneral);                        \
  SetProc(p_Minus_mm_Mult_qq, field, length, ord);                      \
  SetProc(pp_Mult_mm_Noether, field, length, ord);                      \
  SetProc(p_Add_q, field, length, ord);                                 \
  SetProc(p_Neg, field, LengthGeneral, OrdGeneral);                     \
  SetProc(pp_Mult_Coeff_mm_DivSelect, field, length, OrdGeneral);       \
  SetProc(pp_Mult_Coeff_mm_DivSelectMult, field, length, OrdGeneral);   \
  SetProc(p_Merge_q, FieldGeneral, length, ord);                        \
  SetProc(p_kBucketSetLm, field, length, ord);                          \
}                                                                       \
while (0)

SetProcs_ring

#define SetProcs_ring	(		field,
			length,
			ord )

Value:

do                                                                      \
{                                                                       \
  SetProc(p_Copy, FieldGeneral, length, OrdGeneral);                    \
  SetProc(p_Delete, FieldGeneral, LengthGeneral, OrdGeneral);           \
  SetProc(p_ShallowCopyDelete, FieldGeneral, length, OrdGeneral);       \
  SetProc(p_Add_q, FieldGeneral, length, ord);                          \
  SetProc(p_Neg, FieldGeneral, LengthGeneral, OrdGeneral);              \
  SetProc(p_Merge_q, FieldGeneral, length, ord);                        \
  SetProc(p_Mult_nn, field, LengthGeneral, OrdGeneral);                 \
  SetProc(pp_Mult_nn, field, LengthGeneral, OrdGeneral);                \
  SetProc(pp_Mult_mm, field, length, OrdGeneral);                       \
  SetProc(p_Mult_mm, field, length, OrdGeneral);                        \
  SetProc(p_Minus_mm_Mult_qq, field, length, ord);                      \
  SetProc(pp_Mult_mm_Noether, field, length, ord);                      \
  SetProc(pp_Mult_Coeff_mm_DivSelect, field, length, OrdGeneral);       \
  SetProc(pp_Mult_Coeff_mm_DivSelectMult, field, length, OrdGeneral);   \
}                                                                       \
while (0)

Definition at line 698 of file p_Procs_Impl.h.

#define SetProcs_ring(field, length, ord)                               \
do                                                                      \
{                                                                       \
  SetProc(p_Copy, FieldGeneral, length, OrdGeneral);                    \
  SetProc(p_Delete, FieldGeneral, LengthGeneral, OrdGeneral);           \
  SetProc(p_ShallowCopyDelete, FieldGeneral, length, OrdGeneral);       \
  SetProc(p_Add_q, FieldGeneral, length, ord);                          \
  SetProc(p_Neg, FieldGeneral, LengthGeneral, OrdGeneral);              \
  SetProc(p_Merge_q, FieldGeneral, length, ord);                        \
  SetProc(p_Mult_nn, field, LengthGeneral, OrdGeneral);                 \
  SetProc(pp_Mult_nn, field, LengthGeneral, OrdGeneral);                \
  SetProc(pp_Mult_mm, field, length, OrdGeneral);                       \
  SetProc(p_Mult_mm, field, length, OrdGeneral);                        \
  SetProc(p_Minus_mm_Mult_qq, field, length, ord);                      \
  SetProc(pp_Mult_mm_Noether, field, length, ord);                      \
  SetProc(pp_Mult_Coeff_mm_DivSelect, field, length, OrdGeneral);       \
  SetProc(pp_Mult_Coeff_mm_DivSelectMult, field, length, OrdGeneral);   \
}                                                                       \
while (0)

ZP_COPY_FIELD

#define ZP_COPY_FIELD

(

field

)

Value:

  (field == FieldZp || field == FieldGF || field == FieldR)

Definition at line 93 of file p_Procs_Impl.h.

#define ZP_COPY_FIELD(field) \
  (field == FieldZp || field == FieldGF || field == FieldR)

Enumeration Type Documentation

p_Field

enum p_Field

Enumerator
FieldGeneral
FieldZp
FieldQ
FieldR
FieldGF
FieldLong_R
FieldLong_C
FieldZp_a
FieldQ_a
RingGeneral
FieldUnknown

Definition at line 106 of file p_Procs_Impl.h.

{
  FieldGeneral = 0,
  FieldZp,
  FieldQ,
  FieldR,
  FieldGF,
#if HAVE_MORE_FIELDS_IMPLEMENTED
  FieldLong_R,
  FieldLong_C,
  FieldZp_a,
  FieldQ_a,
#endif
  RingGeneral,
  FieldUnknown
} p_Field;

p_Length

enum p_Length

Enumerator
LengthGeneral
LengthEight
LengthSeven
LengthSix
LengthFive
LengthFour
LengthThree
LengthTwo
LengthOne
LengthUnknown

Definition at line 122 of file p_Procs_Impl.h.

{
  LengthGeneral = 0, // n >= 1
  LengthEight,       // n == 8
  LengthSeven,
  LengthSix,
  LengthFive,
  LengthFour,
  LengthThree,
  LengthTwo,
  LengthOne,
  LengthUnknown
} p_Length;

p_Ord

enum p_Ord

Enumerator
OrdGeneral
OrdPomog
OrdNomog
OrdPomogZero
OrdNomogZero
OrdNegPomog
OrdPomogNeg
OrdPosNomog
OrdNomogPos
OrdNegPomogZero
OrdPomogNegZero
OrdPosPosNomog
OrdPosNomogPos
OrdNegPosNomog
OrdNomogPosZero
OrdPosNomogZero
OrdPosPosNomogZero
OrdPosNomogPosZero
OrdNegPosNomogZero
OrdUnknown

Definition at line 135 of file p_Procs_Impl.h.

{
  OrdGeneral = 0,
                    //     ordsgn
                    //  0   1   i   n-1 n   n_min   Example
  OrdPomog,         //  +   +   +   +   +   1       (lp,C)
  OrdNomog,         //  -   -   -   -   -   1       (ls, c), (ds, c)
#define ORD_MAX_N_1 OrdNomog
 
#ifdef HAVE_LENGTH_DIFF
  OrdPomogZero,     //  +   +   +   +   0   2       (Dp, C), Even vars
  OrdNomogZero,     //  -   -   -   -   0   2       (ds, c), Even vars
#endif
 
  OrdNegPomog,      //  -   +   +   +   +   2       (c, lp), (Ds, c)
  OrdPomogNeg,      //  +   +   +   +   -   2       (lp, c)
#define ORD_MAX_N_2 OrdPomogNeg
 
  OrdPosNomog,      //  +   -   -   -   +   3       (dp, c) (for n == 2, use PomogNeg)
  OrdNomogPos,      //  -   -   -   -   +   3       (ls, C) (for n == 2, use NegPomog)
 
#ifdef HAVE_LENGTH_DIFF
  OrdNegPomogZero,  //  -   +   +   +   0   3       (c, lp), (Ds, c)
  OrdPomogNegZero,  //  +   +   +   -   0   3       (lp, c)
#endif
 
  OrdPosPosNomog,   //  +   +   -   -   -   3       (C, dp)
  OrdPosNomogPos,   //  +   -   -   -   +   3       (dp, C)
  OrdNegPosNomog,   //  -   +   -   -   -   3       (c, dp)
#define ORD_MAX_N_3 OrdNegPosNomog
 
#ifdef HAVE_LENGTH_DIFF
  OrdNomogPosZero,  //  -   -   -   +   0   4       (ls, C) (for n == 3, use NegPomogZero)
  OrdPosNomogZero,  //  +   -   -   -   0   4       (dp, c) (for n == 3, use PomogNegZero)
 
  OrdPosPosNomogZero,// +   +   -   -   0   4       (C, dp)
  OrdPosNomogPosZero,// +   -   -   +   0   4       (dp, C)
  OrdNegPosNomogZero,// -   +   -   -   0   4       (c, dp)
#endif
 
  OrdUnknown
} p_Ord;

p_Proc

enum p_Proc

Enumerator
p_Copy_Proc
p_Delete_Proc
p_ShallowCopyDelete_Proc
p_Mult_nn_Proc
pp_Mult_nn_Proc
pp_Mult_mm_Proc
pp_Mult_mm_Noether_Proc
p_Mult_mm_Proc
p_Add_q_Proc
p_Minus_mm_Mult_qq_Proc
p_Neg_Proc
pp_Mult_Coeff_mm_DivSelect_Proc
pp_Mult_Coeff_mm_DivSelectMult_Proc
p_Merge_q_Proc
p_kBucketSetLm_Proc
p_Unknown_Proc

Definition at line 178 of file p_Procs_Impl.h.

{
  p_Copy_Proc = 0,
  p_Delete_Proc,
  p_ShallowCopyDelete_Proc,
  p_Mult_nn_Proc,
  pp_Mult_nn_Proc,
  pp_Mult_mm_Proc,
  pp_Mult_mm_Noether_Proc,
  p_Mult_mm_Proc,
  p_Add_q_Proc,
  p_Minus_mm_Mult_qq_Proc,
  p_Neg_Proc,
  pp_Mult_Coeff_mm_DivSelect_Proc,
  pp_Mult_Coeff_mm_DivSelectMult_Proc,
  p_Merge_q_Proc,
  p_kBucketSetLm_Proc,
  p_Unknown_Proc
} p_Proc;

Function Documentation

FastFieldFilter()

static void FastFieldFilter ( p_Field & field )

inlinestatic

Definition at line 431 of file p_Procs_Impl.h.

{
  if (HAVE_FAST_FIELD <= 0 ||
      (HAVE_FAST_FIELD == 1 && field != FieldZp) ||
      (field != FieldZp && field != FieldQ))
    if (field != RingGeneral) field = FieldGeneral;
}

FastLengthFilter()

static void FastLengthFilter ( p_Length & length )

inlinestatic

Definition at line 439 of file p_Procs_Impl.h.

{
  if ((HAVE_FAST_LENGTH == 3 && length <= LengthFive) ||
      (HAVE_FAST_LENGTH == 2 && length <= LengthFour) ||
      (HAVE_FAST_LENGTH == 1 && length <= LengthTwo) ||
      (HAVE_FAST_LENGTH <= 0))
  {
    length = LengthGeneral;
  }
}

FastOrdFilter()

static void FastOrdFilter ( p_Ord & ord )

inlinestatic

Definition at line 450 of file p_Procs_Impl.h.

{
  if ((HAVE_FAST_ORD == 3 && ord >= OrdNomogPosZero) ||
      (HAVE_FAST_ORD == 2 && ord >= OrdPosNomog) ||
      (HAVE_FAST_ORD == 1 && ord >= OrdPomogZero) ||
      (HAVE_FAST_ORD <= 0))
    ord = OrdGeneral;
}

FastOrdZeroFilter()

static void FastOrdZeroFilter ( p_Ord & ord )

inlinestatic

Definition at line 459 of file p_Procs_Impl.h.

{
  if (IsZeroOrd(ord))
  {
    if ((HAVE_FAST_ZERO_ORD == 1 && (ord != OrdPosNomogPosZero &&
                                     ord != OrdNomogPosZero &&
                                     ord != OrdPomogNegZero)) ||
        (HAVE_FAST_ZERO_ORD <= 0))
      ord = ZeroOrd_2_NonZeroOrd(ord, 1);
  }
}

FastP_ProcsFilter()

static void FastP_ProcsFilter ( p_Field & field, p_Length & length, p_Ord & ord, const p_Proc proc )

inlinestatic

Definition at line 410 of file p_Procs_Impl.h.

{
  if (HAVE_FAST_P_PROCS >= 5) return;
 
  if (HAVE_FAST_P_PROCS < 3 && field == FieldQ)
    field = FieldGeneral;
 
  if ((HAVE_FAST_P_PROCS == 0) ||
      (HAVE_FAST_P_PROCS <= 4 && field != FieldZp && field != FieldQ &&
       proc != p_Merge_q_Proc))
  {
    if (field != RingGeneral) field = FieldGeneral;
    length = LengthGeneral;
    ord = OrdGeneral;
    return;
  }
  if (HAVE_FAST_P_PROCS == 1 ||
      (HAVE_FAST_P_PROCS == 4 && field != FieldZp && proc != p_Merge_q_Proc))
    ord = OrdGeneral;
}

FastProcFilter()

static void FastProcFilter ( p_Proc proc, p_Field & field, p_Length & length, p_Ord & ord )

inlinestatic

Definition at line 518 of file p_Procs_Impl.h.

{
  switch(proc)
  {
      case p_Add_q_Proc:
      case p_Merge_q_Proc:
        p_Add_q__Filter(field, length, ord);
        break;
 
      case p_Neg_Proc:
        p_Neg__Filter(field, length, ord);
        break;
 
      case p_Copy_Proc:
      case p_Delete_Proc:
        NCopy__Filter(field);
        break;
 
      case pp_Mult_mm_Noether_Proc:
        pp_Mult_mm_Noether_Filter(field, length, ord);
        break;
 
        case pp_Mult_Coeff_mm_DivSelectMult_Proc:
          if (length == LengthOne || length == LengthTwo)
          {
            if (field != RingGeneral) field = FieldGeneral;
            length = LengthGeneral;
            ord = OrdGeneral;
            return;
          }
          break;
 
      default: break;
  }
 
  FastOrdFilter(ord);
  FastOrdZeroFilter(ord);
  FastLengthFilter(length);
  FastFieldFilter(field);
  FastP_ProcsFilter(field, length, ord, proc);
#ifdef p_Procs_Static
  StaticKernelFilter(field, length, ord, proc);
#endif
}

index() [1/4]

static int index ( p_Field field, p_Length length )

inlinestatic

Definition at line 597 of file p_Procs_Impl.h.

{
  return field*LengthUnknown + length;
}

index() [2/4]

static int index ( p_Field field, p_Length length, p_Ord ord )

inlinestatic

Definition at line 602 of file p_Procs_Impl.h.

{
  return field*LengthUnknown*OrdUnknown + length*OrdUnknown + ord;
}

index() [3/4]

static int index ( p_Length length, p_Ord ord )

inlinestatic

Definition at line 592 of file p_Procs_Impl.h.

{
  return length*OrdUnknown + ord;
}

index() [4/4]

static int index ( p_Proc proc, p_Field field, p_Length length, p_Ord ord )

inlinestatic

Definition at line 607 of file p_Procs_Impl.h.

{
  switch(proc)
  {
      case p_Delete_Proc:
      case p_Mult_nn_Proc:
      case p_Neg_Proc:
        return field;
 
      case p_ShallowCopyDelete_Proc:
        return length;
 
      case p_Copy_Proc:
      case pp_Mult_mm_Proc:
      case p_Mult_mm_Proc:
      case pp_Mult_nn_Proc:
      case pp_Mult_Coeff_mm_DivSelect_Proc:
      case pp_Mult_Coeff_mm_DivSelectMult_Proc:
        return index(field, length);
 
      case p_Add_q_Proc:
      case p_Minus_mm_Mult_qq_Proc:
      case pp_Mult_mm_Noether_Proc:
      case p_kBucketSetLm_Proc:
        return index(field, length, ord);
 
      case p_Merge_q_Proc:
        return index(length, ord);
 
      default:
        printf("error in index (%d)- should not happen", (int)proc);
        return -1;
  }
}

IsValidSpec()

static int IsValidSpec ( p_Field field, p_Length length, p_Ord ord )

inlinestatic

Definition at line 565 of file p_Procs_Impl.h.

{
  if (field == FieldUnknown || length == LengthUnknown || ord == OrdUnknown)
    return 0;
 
  if (length >= LengthThree && // i.e. 1, 2, or 3
      ord > ORD_MAX_N_3)       //  i.e. OrdNomogPosZero and below
    return 0;
 
  if (length >= LengthTwo &&    // i.e. 1 or 2
      ord > ORD_MAX_N_2)        // i.e. PosNomog and below
    return 0;
 
  if (length == LengthOne &&
      ord > ORD_MAX_N_1)           // i.e. PosPomogZero and below
    return 0;
 
  // we cover everything for length <= two
  if (ord == OrdGeneral && length > LengthTwo)
    return 0;
#ifndef HAVE_RINGS
  if (field == RingGeneral) return 0;
#endif
  return 1;
}

IsZeroOrd()

static int IsZeroOrd ( p_Ord ord )

inlinestatic

Definition at line 349 of file p_Procs_Impl.h.

{
  return (ord == OrdPomogZero || ord == OrdNomogZero ||
          ord == OrdNegPomogZero || ord == OrdPosNomogZero ||
          ord == OrdPomogNegZero || ord == OrdNomogPosZero ||
          ord == OrdPosNomogPosZero || ord == OrdPosPosNomogZero ||
          ord == OrdNegPosNomogZero);
}

NCopy__Filter()

static void NCopy__Filter ( p_Field & field )

inlinestatic

Definition at line 471 of file p_Procs_Impl.h.

{
  if (ZP_COPY_FIELD(field)) field = FieldZp;
  else if (field == RingGeneral) field = FieldGeneral;
}

p_Add_q__Filter()

static void p_Add_q__Filter ( p_Field & field, p_Length & length, p_Ord & ord )

inlinestatic

Definition at line 479 of file p_Procs_Impl.h.

{
  if (IsZeroOrd(ord))
  {
    ord = ZeroOrd_2_NonZeroOrd(ord, 0);
    if (length > LengthGeneral)
    {
      length = (p_Length) ((int)length + 1);
    }
  }
  if (field == RingGeneral) field = FieldGeneral;
}

p_FieldEnum_2_String()

static const char * p_FieldEnum_2_String ( p_Field field )

inlinestatic

Definition at line 198 of file p_Procs_Impl.h.

{
  switch(field)
  {
      case FieldGeneral: return "FieldGeneral";
      case FieldZp: return "FieldZp";
      case FieldQ: return "FieldQ";
      case FieldR: return "FieldR";
      case FieldGF: return "FieldGF";
#if HAVE_MORE_FIELDS_IMPLEMENTED
      case FieldLong_R: return "FieldLong_R";
      case FieldLong_C: return "FieldLong_C";
      case FieldZp_a: return "FieldZp_a";
      case FieldQ_a: return "FieldQ_a";
#endif
      case RingGeneral: return "RingGeneral";
      case FieldUnknown: return "FieldUnknown";
  }
  return "NoField_2_String";
}

p_LengthEnum_2_String()

static const char * p_LengthEnum_2_String ( p_Length length )

inlinestatic

Definition at line 219 of file p_Procs_Impl.h.

{
  switch(length)
  {
      case LengthGeneral: return "LengthGeneral";
      case LengthEight: return "LengthEight";
      case LengthSeven: return "LengthSeven";
      case LengthSix: return "LengthSix";
      case LengthFive: return "LengthFive";
      case LengthFour: return "LengthFour";
      case LengthThree: return "LengthThree";
      case LengthTwo: return "LengthTwo";
      case LengthOne: return "LengthOne";
      case LengthUnknown: return "LengthUnknown";
  }
  return "NoLength_2_String";
}

p_Neg__Filter()

static void p_Neg__Filter ( p_Field & field, p_Length & length, p_Ord & ord )

inlinestatic

Definition at line 492 of file p_Procs_Impl.h.

{
  if (field == RingGeneral) field = FieldGeneral;
  length =LengthGeneral;
  ord =OrdGeneral;
}

p_OrdEnum_2_String()

static const char * p_OrdEnum_2_String ( p_Ord ord )

inlinestatic

Definition at line 237 of file p_Procs_Impl.h.

{
  switch(ord)
  {
      case OrdGeneral: return "OrdGeneral";
      case OrdPomog: return "OrdPomog";
      case OrdNomog: return "OrdNomog";
      case OrdNegPomog: return "OrdNegPomog";
      case OrdPomogNeg: return "OrdPomogNeg";
      case OrdPosNomog: return "OrdPosNomog";
      case OrdNomogPos: return "OrdNomogPos";
      case OrdPosPosNomog: return "OrdPosPosNomog";
      case OrdPosNomogPos: return "OrdPosNomogPos";
      case OrdNegPosNomog: return "OrdNegPosNomog";
#ifdef HAVE_LENGTH_DIFF
      case OrdNegPomogZero: return "OrdNegPomogZero";
      case OrdPomogNegZero: return "OrdPomogNegZero";
      case OrdPomogZero: return "OrdPomogZero";
      case OrdNomogZero: return "OrdNomogZero";
      case OrdNomogPosZero: return "OrdNomogPosZero";
      case OrdPosNomogZero: return "OrdPosNomogZero";
      case OrdPosPosNomogZero: return "OrdPosPosNomogZero";
      case OrdPosNomogPosZero: return "OrdPosNomogPosZero";
      case OrdNegPosNomogZero: return "OrdNegPosNomogZero";
#endif
      case OrdUnknown: return "OrdUnknown";
  }
  return "NoOrd_2_String";
}

p_ProcDependsOn_Field()

static int p_ProcDependsOn_Field ( p_Proc proc )

inlinestatic

Definition at line 291 of file p_Procs_Impl.h.

{
  if (proc == p_ShallowCopyDelete_Proc ||
      proc == p_Merge_q_Proc)
    return 0;
  return 1;
}

p_ProcDependsOn_Length()

static int p_ProcDependsOn_Length ( p_Proc proc )

inlinestatic

Definition at line 315 of file p_Procs_Impl.h.

{
  switch(proc)
  {
      case p_Delete_Proc:
      case p_Mult_nn_Proc:
      case p_Neg_Proc:
        return 0;
 
      default:
        return 1;
  }
}

p_ProcDependsOn_Ord()

static int p_ProcDependsOn_Ord ( p_Proc proc )

inlinestatic

Definition at line 299 of file p_Procs_Impl.h.

{
  switch(proc)
  {
      case p_Add_q_Proc:
      case p_Minus_mm_Mult_qq_Proc:
      case pp_Mult_mm_Noether_Proc:
      case p_kBucketSetLm_Proc:
      case p_Merge_q_Proc:
        return 1;
 
      default:
        return 0;
  }
}

p_ProcEnum_2_String()

static const char * p_ProcEnum_2_String ( p_Proc proc )

inlinestatic

Definition at line 267 of file p_Procs_Impl.h.

{
  switch(proc)
  {
      case p_Copy_Proc: return "p_Copy_Proc";
      case p_Delete_Proc: return "p_Delete_Proc";
      case p_ShallowCopyDelete_Proc: return "p_ShallowCopyDelete_Proc";
      case p_Mult_nn_Proc: return "p_Mult_nn_Proc";
      case pp_Mult_nn_Proc: return "pp_Mult_nn_Proc";
      case pp_Mult_mm_Proc: return "pp_Mult_mm_Proc";
      case pp_Mult_mm_Noether_Proc: return "pp_Mult_mm_Noether_Proc";
      case p_Mult_mm_Proc: return "p_Mult_mm_Proc";
      case p_Add_q_Proc: return "p_Add_q_Proc";
      case p_Minus_mm_Mult_qq_Proc: return "p_Minus_mm_Mult_qq_Proc";
      case p_Neg_Proc: return "p_Neg_Proc";
      case pp_Mult_Coeff_mm_DivSelect_Proc: return "pp_Mult_Coeff_mm_DivSelect_Proc";
      case pp_Mult_Coeff_mm_DivSelectMult_Proc: return "pp_Mult_Coeff_mm_DivSelectMult_Proc";
      case p_Merge_q_Proc: return "p_Merge_q_Proc";
      case p_kBucketSetLm_Proc: return "p_kBucketSetLm_Proc";
      case p_Unknown_Proc: return "p_Unknown_Proc";
  }
  return "NoProc_2_String";
}

p_ProcField_2_Module()

static const char * p_ProcField_2_Module ( p_Proc proc, p_Field field )

inlinestatic

Definition at line 331 of file p_Procs_Impl.h.

{
  if (! p_ProcDependsOn_Field(proc))
    return "FieldIndep";
  else
  {
    if (field > FieldQ) field = FieldGeneral;
    return p_FieldEnum_2_String(field);
  }
}

pp_Mult_mm_Noether_Filter()

static void pp_Mult_mm_Noether_Filter ( p_Field & field, p_Length & length, p_Ord & ord )

inlinestatic

Definition at line 499 of file p_Procs_Impl.h.

{
  if (ord == OrdPomog
      || ord == OrdPomogZero
      || (ord == OrdPomogNeg && length > LengthTwo)
#ifdef HAVE_LENGTH_DIFF
      || (ord == OrdPomogZero)
      || (ord == OrdPomogNegZero && length > LengthThree)
#endif
      )
  {
    // all the other orderings might occur (remember Mixed Orderings!)
    if (field != RingGeneral) field = FieldGeneral;
    ord = OrdGeneral;
    length = LengthGeneral;
  }
}

ZeroOrd_2_NonZeroOrd()

static p_Ord ZeroOrd_2_NonZeroOrd ( p_Ord ord, int strict )

inlinestatic

Definition at line 358 of file p_Procs_Impl.h.

{
  if (IsZeroOrd(ord))
  {
    switch (ord)
    {
        case OrdPomogZero:      return OrdPomog;
        case OrdNomogZero:      return OrdNomog;
        case OrdNegPomogZero:   return OrdNegPomog;
        case OrdPosNomogZero:   return OrdPosNomog;
        case OrdPosPosNomogZero:    return OrdPosPosNomog;
        case OrdNegPosNomogZero:    return OrdNegPosNomog;
        default:
          if (strict) return OrdGeneral;
          else if (ord == OrdPomogNegZero) return OrdPomogNeg;
          else if (ord == OrdNomogPosZero) return OrdNomogPos;
          else if (ord == OrdPosNomogPosZero) return OrdPosNomogPos;
          else return OrdGeneral;
    }
  }
  else
  {
    return ord;
  }
}