Loading...
Searching...
No Matches
p_Procs_Impl.h
Go to the documentation of this file.
/****************************************
* Computer Algebra System SINGULAR *
****************************************/
/***************************************************************
* File: p_Procs_Impl.h
* Purpose: implementation of primitive procs for polys
* Author: obachman (Olaf Bachmann)
* Created: 12/00
*******************************************************************/
#ifndef P_PROCS_IMPL_H
#define P_PROCS_IMPL_H
#include "misc/auxiliary.h"
/***************************************************************
*
* Configurations
*
*******************************************************************/
/***************************************************************
Here is how it works:
At run-time, SetProcs is used to choose the appropriate PolyProcs
based on the ring properties.
At generate-time, SetProcs is used to generate all
possible PolyProcs.
Which PolyProcs are generated/used can be controlled by values of
HAVE_FAST_P_PROCS, HAVE_FAST_LENGTH, HAVE_FAST_ORD, and FAST_FIELD
At generate-time, the file p_Procs.inc is generated,
which provides implementations of the p_Procs, based on
the p_*_Templates.cc and header files which provide the respective
macros.
At run-time, a fast proc is set/chosen if found/generated, else
a general proc is set/chosen.
*******************************************************************/
// Define HAVE_FAST_P_PROCS to:
// 0 -- only FieldGeneral_LengthGeneral_OrdGeneral
// 1 -- plus FieldZp_Length*_OrdGeneral procs
// 2 -- plus FieldZp_Length*_Ord* procs
// 3 -- plus FieldQ_Length*_Ord*
// 4 -- plus FieldGeneral_Length*_OrdGeneral procs
// 5 -- all Field*_Length*_Ord* procs
#ifndef HAVE_FAST_P_PROCS
#define HAVE_FAST_P_PROCS 0
#endif
// Define HAVE_FAST_FIELD to:
// 0 -- only FieldGeneral
// 1 -- special cases for FieldZp
// 2 -- plus special cases for FieldQ
// nothing else is implemented, yet
#ifndef HAVE_FAST_FIELD
#define HAVE_FAST_FIELD 0
#endif
// Define HAVE_FAST_LENGTH to:
// 0 -- only LengthGeneral
// 1 -- special cases for length <= 1
// 2 -- special cases for length <= 2
// 3 -- special cases for length <= 4
// 4 -- special cases for length <= 8
#ifndef HAVE_FAST_LENGTH
#define HAVE_FAST_LENGTH 0
#endif
// Define HAVE_FAST_ORD to:
// 0 -- only OrdGeneral
// 1 -- special for ords with n_min <= 1
// 2 -- special for ords with n_min <= 2
// 3 -- special ords for with n_min <= 3
// 4 -- special for all ords
#ifndef HAVE_FAST_ORD
#define HAVE_FAST_ORD 0
#endif
// Define HAVE_FAST_ZERO_ORD to:
// 0 -- no zero ords are considered
// 1 -- only ZeroOrds for OrdPosNomogPosZero, OrdNomogPosZero, OrdPomogNegZero
// 2 -- ZeroOrds for all
#ifndef HAVE_FAST_ZERO_ORD
#define HAVE_FAST_ZERO_ORD 0
#endif
// undefine this, if ExpL_Size always equals CompLSize
#define HAVE_LENGTH_DIFF
// Predicate which returns true if alloc/copy/free of numbers is
// like that of Zp (rings should use GMP in future)
#define ZP_COPY_FIELD(field) \
(field == FieldZp || field == FieldGF || field == FieldR)
/***************************************************************
*
* Definitions of our fields, lengths, ords, procs we work with
*
*******************************************************************/
// Here are the different parameters for setting the PolyProcs:
// If you add/remove things from here, also remember to adjust the
// respective *_2_String
typedef enum p_Field
{
FieldGeneral = 0,
FieldZp,
FieldQ,
FieldR,
FieldGF,
#if HAVE_MORE_FIELDS_IMPLEMENTED
FieldLong_R,
FieldLong_C,
FieldZp_a,
FieldQ_a,
#endif
RingGeneral,
FieldUnknown
} p_Field;
typedef enum p_Length // Length of exponent vector in words
{
LengthGeneral = 0, // n >= 1
LengthEight, // n == 8
LengthSeven,
LengthSix,
LengthFive,
LengthFour,
LengthThree,
LengthTwo,
LengthOne,
LengthUnknown
} p_Length;
typedef enum p_Ord
{
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;
typedef 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
} p_Proc;
static inline const char* p_FieldEnum_2_String(p_Field field)
{
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";
}
static inline const char* p_LengthEnum_2_String(p_Length length)
{
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";
}
static inline const char* p_OrdEnum_2_String(p_Ord ord)
{
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";
}
static inline const char* p_ProcEnum_2_String(p_Proc proc)
{
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";
}
static inline int p_ProcDependsOn_Field(p_Proc proc)
{
if (proc == p_ShallowCopyDelete_Proc ||
proc == p_Merge_q_Proc)
return 0;
return 1;
}
static inline int p_ProcDependsOn_Ord(p_Proc proc)
{
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;
}
}
static inline int p_ProcDependsOn_Length(p_Proc proc)
{
switch(proc)
{
case p_Delete_Proc:
case p_Mult_nn_Proc:
case p_Neg_Proc:
return 0;
default:
return 1;
}
}
// returns string specifying the module into which the p_Proc
// should go
static inline const char* p_ProcField_2_Module(p_Proc proc, p_Field field)
{
if (! p_ProcDependsOn_Field(proc))
return "FieldIndep";
else
{
if (field > FieldQ) field = FieldGeneral;
return p_FieldEnum_2_String(field);
}
}
/***************************************************************
*
*
* Deal with OrdZero
*
*******************************************************************/
#ifdef HAVE_LENGTH_DIFF
static inline int IsZeroOrd(p_Ord ord)
{
return (ord == OrdPomogZero || ord == OrdNomogZero ||
ord == OrdNegPomogZero || ord == OrdPosNomogZero ||
ord == OrdPomogNegZero || ord == OrdNomogPosZero ||
ord == OrdPosNomogPosZero || ord == OrdPosPosNomogZero ||
ord == OrdNegPosNomogZero);
}
static inline p_Ord ZeroOrd_2_NonZeroOrd(p_Ord ord, int strict)
{
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;
}
}
#else
#define IsZeroOrd(ord) 0
#define ZeroOrd_2_NonZeroOrd(ord) (ord)
#endif
/***************************************************************
*
* Filters which are applied to field/length/ord, before a proc is
* chosen
*
*******************************************************************/
#ifdef p_Procs_Static
static inline void StaticKernelFilter(p_Field &field, p_Length &length,
p_Ord &ord, const p_Proc proc)
{
// simply exclude some things
if ((proc == pp_Mult_mm_Noether_Proc || proc == p_kBucketSetLm_Proc) &&
(field != RingGeneral) &&
(field != FieldZp))
{
field = FieldGeneral;
length = LengthGeneral;
ord = OrdGeneral;
}
}
#endif
static inline void FastP_ProcsFilter(p_Field &field, p_Length &length, p_Ord &ord, const p_Proc proc)
{
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;
}
static inline void FastFieldFilter(p_Field &field)
{
if (HAVE_FAST_FIELD <= 0 ||
(HAVE_FAST_FIELD == 1 && field != FieldZp) ||
(field != FieldZp && field != FieldQ))
if (field != RingGeneral) field = FieldGeneral;
}
static inline void FastLengthFilter(p_Length &length)
{
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;
}
}
static inline void FastOrdFilter(p_Ord &ord)
{
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;
}
static inline void FastOrdZeroFilter(p_Ord &ord)
{
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);
}
}
static inline void NCopy__Filter(p_Field &field)
{
if (ZP_COPY_FIELD(field)) field = FieldZp;
else if (field == RingGeneral) field = FieldGeneral;
}
// in p_Add_q, p_MemCmp works with CompLSize,
// hence, we do not need to consider ZeroOrds
static inline void p_Add_q__Filter(p_Field &field,p_Length &length, p_Ord &ord)
{
if (IsZeroOrd(ord))
{
ord = ZeroOrd_2_NonZeroOrd(ord, 0);
if (length > LengthGeneral)
{
length = (p_Length) ((int)length + 1);
}
}
if (field == RingGeneral) field = FieldGeneral;
}
static inline void p_Neg__Filter(p_Field &field,p_Length &length, p_Ord &ord)
{
if (field == RingGeneral) field = FieldGeneral;
length =LengthGeneral;
ord =OrdGeneral;
}
static inline void pp_Mult_mm_Noether_Filter(p_Field &field,
p_Length &length, p_Ord &ord)
{
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;
}
}
static inline void FastProcFilter(p_Proc proc, p_Field &field,
p_Length &length, p_Ord &ord)
{
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
}
// returns 0 if combination of field/length/ord is invalid
static inline int IsValidSpec(p_Field field, p_Length length, p_Ord ord)
{
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;
}
static inline int index(p_Length length, p_Ord ord)
{
return length*OrdUnknown + ord;
}
static inline int index(p_Field field, p_Length length)
{
return field*LengthUnknown + length;
}
static inline int index(p_Field field, p_Length length, p_Ord ord)
{
return field*LengthUnknown*OrdUnknown + length*OrdUnknown + ord;
}
static inline int index(p_Proc proc, p_Field field, p_Length length, p_Ord ord)
{
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;
}
}
/***************************************************************
*
* Macros for setting procs -- these are used for
* generation and setting
*
***************************************************************/
#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) \
#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)
#ifdef NV_OPS
#define SetProcs_nv(field, length, ord) \
do \
{ \
SetProc(p_Delete, field, LengthGeneral, OrdGeneral); \
SetProc(p_ShallowCopyDelete, FieldGeneral, length, OrdGeneral); \
SetProc(p_Copy, field, length, OrdGeneral); \
SetProc(p_Add_q, field, length, ord); \
SetProc(p_kBucketSetLm, field, length, ord); \
SetProc(p_Neg, field, LengthGeneral, OrdGeneral); \
SetProc(p_Merge_q, FieldGeneral, length, ord); \
} \
while (0)
#endif
#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)
#endif // P_PROCS_IMPL_H
auxiliary.h
All the auxiliary stuff.
proc
unsigned char * proc[NUM_PROC]
Definition checklibs.c:16
length
static BOOLEAN length(leftv result, leftv arg)
Definition interval.cc:257
HAVE_FAST_LENGTH
#define HAVE_FAST_LENGTH
Definition p_Procs_Dynamic.h:25
HAVE_FAST_P_PROCS
#define HAVE_FAST_P_PROCS
Definition p_Procs_Dynamic.h:16
HAVE_FAST_ZERO_ORD
#define HAVE_FAST_ZERO_ORD
Definition p_Procs_Dynamic.h:19
HAVE_FAST_FIELD
#define HAVE_FAST_FIELD
Definition p_Procs_Dynamic.h:17
HAVE_FAST_ORD
#define HAVE_FAST_ORD
Definition p_Procs_Dynamic.h:18
ORD_MAX_N_2
#define ORD_MAX_N_2
Definition p_Procs_Impl.h:151
p_ProcDependsOn_Ord
static int p_ProcDependsOn_Ord(p_Proc proc)
Definition p_Procs_Impl.h:299
p_Length
p_Length
Definition p_Procs_Impl.h:123
LengthFive
@ LengthFive
Definition p_Procs_Impl.h:128
LengthUnknown
@ LengthUnknown
Definition p_Procs_Impl.h:133
LengthFour
@ LengthFour
Definition p_Procs_Impl.h:129
LengthThree
@ LengthThree
Definition p_Procs_Impl.h:130
LengthEight
@ LengthEight
Definition p_Procs_Impl.h:125
LengthSix
@ LengthSix
Definition p_Procs_Impl.h:127
LengthGeneral
@ LengthGeneral
Definition p_Procs_Impl.h:124
LengthOne
@ LengthOne
Definition p_Procs_Impl.h:132
LengthSeven
@ LengthSeven
Definition p_Procs_Impl.h:126
LengthTwo
@ LengthTwo
Definition p_Procs_Impl.h:131
FastOrdZeroFilter
static void FastOrdZeroFilter(p_Ord &ord)
Definition p_Procs_Impl.h:459
index
static int index(p_Length length, p_Ord ord)
Definition p_Procs_Impl.h:592
p_ProcDependsOn_Field
static int p_ProcDependsOn_Field(p_Proc proc)
Definition p_Procs_Impl.h:291
p_Neg__Filter
static void p_Neg__Filter(p_Field &field, p_Length &length, p_Ord &ord)
Definition p_Procs_Impl.h:492
HAVE_LENGTH_DIFF
#define HAVE_LENGTH_DIFF
Definition p_Procs_Impl.h:88
p_ProcField_2_Module
static const char * p_ProcField_2_Module(p_Proc proc, p_Field field)
Definition p_Procs_Impl.h:331
p_Field
p_Field
Definition p_Procs_Impl.h:107
FieldUnknown
@ FieldUnknown
Definition p_Procs_Impl.h:120
FieldQ
@ FieldQ
Definition p_Procs_Impl.h:110
FieldZp
@ FieldZp
Definition p_Procs_Impl.h:109
RingGeneral
@ RingGeneral
Definition p_Procs_Impl.h:119
FieldZp_a
@ FieldZp_a
Definition p_Procs_Impl.h:116
FieldQ_a
@ FieldQ_a
Definition p_Procs_Impl.h:117
FieldLong_R
@ FieldLong_R
Definition p_Procs_Impl.h:114
FieldLong_C
@ FieldLong_C
Definition p_Procs_Impl.h:115
FieldR
@ FieldR
Definition p_Procs_Impl.h:111
FieldGeneral
@ FieldGeneral
Definition p_Procs_Impl.h:108
FieldGF
@ FieldGF
Definition p_Procs_Impl.h:112
pp_Mult_mm_Noether_Filter
static void pp_Mult_mm_Noether_Filter(p_Field &field, p_Length &length, p_Ord &ord)
Definition p_Procs_Impl.h:499
FastFieldFilter
static void FastFieldFilter(p_Field &field)
Definition p_Procs_Impl.h:431
IsZeroOrd
static int IsZeroOrd(p_Ord ord)
Definition p_Procs_Impl.h:349
p_ProcDependsOn_Length
static int p_ProcDependsOn_Length(p_Proc proc)
Definition p_Procs_Impl.h:315
p_Proc
p_Proc
Definition p_Procs_Impl.h:179
p_ShallowCopyDelete_Proc
@ p_ShallowCopyDelete_Proc
Definition p_Procs_Impl.h:182
p_Delete_Proc
@ p_Delete_Proc
Definition p_Procs_Impl.h:181
p_kBucketSetLm_Proc
@ p_kBucketSetLm_Proc
Definition p_Procs_Impl.h:194
p_Neg_Proc
@ p_Neg_Proc
Definition p_Procs_Impl.h:190
p_Mult_nn_Proc
@ p_Mult_nn_Proc
Definition p_Procs_Impl.h:183
p_Mult_mm_Proc
@ p_Mult_mm_Proc
Definition p_Procs_Impl.h:187
pp_Mult_nn_Proc
@ pp_Mult_nn_Proc
Definition p_Procs_Impl.h:184
pp_Mult_Coeff_mm_DivSelect_Proc
@ pp_Mult_Coeff_mm_DivSelect_Proc
Definition p_Procs_Impl.h:191
p_Merge_q_Proc
@ p_Merge_q_Proc
Definition p_Procs_Impl.h:193
p_Copy_Proc
@ p_Copy_Proc
Definition p_Procs_Impl.h:180
p_Add_q_Proc
@ p_Add_q_Proc
Definition p_Procs_Impl.h:188
pp_Mult_mm_Proc
@ pp_Mult_mm_Proc
Definition p_Procs_Impl.h:185
pp_Mult_Coeff_mm_DivSelectMult_Proc
@ pp_Mult_Coeff_mm_DivSelectMult_Proc
Definition p_Procs_Impl.h:192
p_Minus_mm_Mult_qq_Proc
@ p_Minus_mm_Mult_qq_Proc
Definition p_Procs_Impl.h:189
pp_Mult_mm_Noether_Proc
@ pp_Mult_mm_Noether_Proc
Definition p_Procs_Impl.h:186
p_Unknown_Proc
@ p_Unknown_Proc
Definition p_Procs_Impl.h:195
FastP_ProcsFilter
static void FastP_ProcsFilter(p_Field &field, p_Length &length, p_Ord &ord, const p_Proc proc)
Definition p_Procs_Impl.h:410
ZP_COPY_FIELD
#define ZP_COPY_FIELD(field)
Definition p_Procs_Impl.h:93
p_FieldEnum_2_String
static const char * p_FieldEnum_2_String(p_Field field)
Definition p_Procs_Impl.h:198
ZeroOrd_2_NonZeroOrd
static p_Ord ZeroOrd_2_NonZeroOrd(p_Ord ord, int strict)
Definition p_Procs_Impl.h:358
ORD_MAX_N_1
#define ORD_MAX_N_1
Definition p_Procs_Impl.h:142
NCopy__Filter
static void NCopy__Filter(p_Field &field)
Definition p_Procs_Impl.h:471
p_Ord
p_Ord
Definition p_Procs_Impl.h:136
OrdNomogZero
@ OrdNomogZero
Definition p_Procs_Impl.h:146
OrdPomogNegZero
@ OrdPomogNegZero
Definition p_Procs_Impl.h:158
OrdPosNomog
@ OrdPosNomog
Definition p_Procs_Impl.h:153
OrdNegPomogZero
@ OrdNegPomogZero
Definition p_Procs_Impl.h:157
OrdPosNomogPosZero
@ OrdPosNomogPosZero
Definition p_Procs_Impl.h:171
OrdNegPomog
@ OrdNegPomog
Definition p_Procs_Impl.h:149
OrdPomogNeg
@ OrdPomogNeg
Definition p_Procs_Impl.h:150
OrdPomog
@ OrdPomog
Definition p_Procs_Impl.h:140
OrdUnknown
@ OrdUnknown
Definition p_Procs_Impl.h:175
OrdPosNomogZero
@ OrdPosNomogZero
Definition p_Procs_Impl.h:168
OrdPosPosNomogZero
@ OrdPosPosNomogZero
Definition p_Procs_Impl.h:170
OrdPosNomogPos
@ OrdPosNomogPos
Definition p_Procs_Impl.h:162
OrdGeneral
@ OrdGeneral
Definition p_Procs_Impl.h:137
OrdNomog
@ OrdNomog
Definition p_Procs_Impl.h:141
OrdNegPosNomogZero
@ OrdNegPosNomogZero
Definition p_Procs_Impl.h:172
OrdNomogPos
@ OrdNomogPos
Definition p_Procs_Impl.h:154
OrdPomogZero
@ OrdPomogZero
Definition p_Procs_Impl.h:145
OrdPosPosNomog
@ OrdPosPosNomog
Definition p_Procs_Impl.h:161
OrdNegPosNomog
@ OrdNegPosNomog
Definition p_Procs_Impl.h:163
OrdNomogPosZero
@ OrdNomogPosZero
Definition p_Procs_Impl.h:167
p_Add_q__Filter
static void p_Add_q__Filter(p_Field &field, p_Length &length, p_Ord &ord)
Definition p_Procs_Impl.h:479
p_OrdEnum_2_String
static const char * p_OrdEnum_2_String(p_Ord ord)
Definition p_Procs_Impl.h:237
FastLengthFilter
static void FastLengthFilter(p_Length &length)
Definition p_Procs_Impl.h:439
p_LengthEnum_2_String
static const char * p_LengthEnum_2_String(p_Length length)
Definition p_Procs_Impl.h:219
FastOrdFilter
static void FastOrdFilter(p_Ord &ord)
Definition p_Procs_Impl.h:450
FastProcFilter
static void FastProcFilter(p_Proc proc, p_Field &field, p_Length &length, p_Ord &ord)
Definition p_Procs_Impl.h:518
p_ProcEnum_2_String
static const char * p_ProcEnum_2_String(p_Proc proc)
Definition p_Procs_Impl.h:267
ORD_MAX_N_3
#define ORD_MAX_N_3
Definition p_Procs_Impl.h:164
IsValidSpec
static int IsValidSpec(p_Field field, p_Length length, p_Ord ord)
Definition p_Procs_Impl.h:565