My Project
Loading...
Searching...
No Matches
p_Procs_Impl.h
Go to the documentation of this file.
1/****************************************
2* Computer Algebra System SINGULAR *
3****************************************/
4/***************************************************************
5 * File: p_Procs_Impl.h
6 * Purpose: implementation of primitive procs for polys
7 * Author: obachman (Olaf Bachmann)
8 * Created: 12/00
9 *******************************************************************/
10#ifndef P_PROCS_IMPL_H
11#define P_PROCS_IMPL_H
12
13#include "misc/auxiliary.h"
14
15/***************************************************************
16 *
17 * Configurations
18 *
19 *******************************************************************/
20
21/***************************************************************
22 Here is how it works:
23 At run-time, SetProcs is used to choose the appropriate PolyProcs
24 based on the ring properties.
25 At generate-time, SetProcs is used to generate all
26 possible PolyProcs.
27 Which PolyProcs are generated/used can be controled by values of
28 HAVE_FAST_P_PROCS, HAVE_FAST_LENGTH, HAVE_FAST_ORD, and FAST_FIELD
29
30 At generate-time, the file p_Procs.inc is generated,
31 which provides implementations of the p_Procs, based on
32 the p_*_Templates.cc and header files which provide the respective
33 macros.
34
35 At run-time, a fast proc is set/chosen if found/generated, else
36 a general proc is set/chosen.
37 *******************************************************************/
38
39// Define HAVE_FAST_P_PROCS to:
40// 0 -- only FieldGeneral_LengthGeneral_OrdGeneral
41// 1 -- plus FieldZp_Length*_OrdGeneral procs
42// 2 -- plus FieldZp_Length*_Ord* procs
43// 3 -- plus FieldQ_Length*_Ord*
44// 4 -- plus FieldGeneral_Length*_OrdGeneral procs
45// 5 -- all Field*_Length*_Ord* procs
46#ifndef HAVE_FAST_P_PROCS
47#define HAVE_FAST_P_PROCS 0
48#endif
49
50// Define HAVE_FAST_FIELD to:
51// 0 -- only FieldGeneral
52// 1 -- special cases for FieldZp
53// 2 -- plus special cases for FieldQ
54// nothing else is implemented, yet
55#ifndef HAVE_FAST_FIELD
56#define HAVE_FAST_FIELD 0
57#endif
58
59// Define HAVE_FAST_LENGTH to:
60// 0 -- only LengthGeneral
61// 1 -- special cases for length <= 1
62// 2 -- special cases for length <= 2
63// 3 -- special cases for length <= 4
64// 4 -- special cases for length <= 8
65#ifndef HAVE_FAST_LENGTH
66#define HAVE_FAST_LENGTH 0
67#endif
68
69// Define HAVE_FAST_ORD to:
70// 0 -- only OrdGeneral
71// 1 -- special for ords with n_min <= 1
72// 2 -- special for ords with n_min <= 2
73// 3 -- special ords for with n_min <= 3
74// 4 -- special for all ords
75#ifndef HAVE_FAST_ORD
76#define HAVE_FAST_ORD 0
77#endif
78
79// Define HAVE_FAST_ZERO_ORD to:
80// 0 -- no zero ords are considered
81// 1 -- only ZeroOrds for OrdPosNomogPosZero, OrdNomogPosZero, OrdPomogNegZero
82// 2 -- ZeroOrds for all
83#ifndef HAVE_FAST_ZERO_ORD
84#define HAVE_FAST_ZERO_ORD 0
85#endif
86
87// undefine this, if ExpL_Size always equals CompLSize
88#define HAVE_LENGTH_DIFF
89
90
91// Predicate which returns true if alloc/copy/free of numbers is
92// like that of Zp (rings should use GMP in future)
93#define ZP_COPY_FIELD(field) \
94 (field == FieldZp || field == FieldGF || field == FieldR)
95
96/***************************************************************
97 *
98 * Definitions of our fields, lengths, ords, procs we work with
99 *
100 *******************************************************************/
101
102// Here are the different parameters for setting the PolyProcs:
103
104// If you add/remove things from here, also remeber to adjust the
105// respective *_2_String
106typedef enum p_Field
107{
113#if HAVE_MORE_FIELDS_IMPLEMENTED
118#endif
122typedef enum p_Length // Length of exponent vector in words
123{
124 LengthGeneral = 0, // n >= 1
125 LengthEight, // n == 8
135typedef enum p_Ord
136{
138 // ordsgn
139 // 0 1 i n-1 n n_min Example
140 OrdPomog, // + + + + + 1 (lp,C)
141 OrdNomog, // - - - - - 1 (ls, c), (ds, c)
142#define ORD_MAX_N_1 OrdNomog
143
144#ifdef HAVE_LENGTH_DIFF
145 OrdPomogZero, // + + + + 0 2 (Dp, C), Even vars
146 OrdNomogZero, // - - - - 0 2 (ds, c), Even vars
147#endif
148
149 OrdNegPomog, // - + + + + 2 (c, lp), (Ds, c)
150 OrdPomogNeg, // + + + + - 2 (lp, c)
151#define ORD_MAX_N_2 OrdPomogNeg
152
153 OrdPosNomog, // + - - - + 3 (dp, c) (for n == 2, use PomogNeg)
154 OrdNomogPos, // - - - - + 3 (ls, C) (for n == 2, use NegPomog)
155
156#ifdef HAVE_LENGTH_DIFF
157 OrdNegPomogZero, // - + + + 0 3 (c, lp), (Ds, c)
158 OrdPomogNegZero, // + + + - 0 3 (lp, c)
159#endif
160
161 OrdPosPosNomog, // + + - - - 3 (C, dp)
162 OrdPosNomogPos, // + - - - + 3 (dp, C)
163 OrdNegPosNomog, // - + - - - 3 (c, dp)
164#define ORD_MAX_N_3 OrdNegPosNomog
165
166#ifdef HAVE_LENGTH_DIFF
167 OrdNomogPosZero, // - - - + 0 4 (ls, C) (for n == 3, use NegPomogZero)
168 OrdPosNomogZero, // + - - - 0 4 (dp, c) (for n == 3, use PomogNegZero)
169
170 OrdPosPosNomogZero,// + + - - 0 4 (C, dp)
171 OrdPosNomogPosZero,// + - - + 0 4 (dp, C)
172 OrdNegPosNomogZero,// - + - - 0 4 (c, dp)
173#endif
174
177
178typedef enum p_Proc
179{
197
198static inline const char* p_FieldEnum_2_String(p_Field field)
199{
200 switch(field)
201 {
202 case FieldGeneral: return "FieldGeneral";
203 case FieldZp: return "FieldZp";
204 case FieldQ: return "FieldQ";
205 case FieldR: return "FieldR";
206 case FieldGF: return "FieldGF";
207#if HAVE_MORE_FIELDS_IMPLEMENTED
208 case FieldLong_R: return "FieldLong_R";
209 case FieldLong_C: return "FieldLong_C";
210 case FieldZp_a: return "FieldZp_a";
211 case FieldQ_a: return "FieldQ_a";
212#endif
213 case RingGeneral: return "RingGeneral";
214 case FieldUnknown: return "FieldUnknown";
215 }
216 return "NoField_2_String";
217}
218
219static inline const char* p_LengthEnum_2_String(p_Length length)
220{
221 switch(length)
222 {
223 case LengthGeneral: return "LengthGeneral";
224 case LengthEight: return "LengthEight";
225 case LengthSeven: return "LengthSeven";
226 case LengthSix: return "LengthSix";
227 case LengthFive: return "LengthFive";
228 case LengthFour: return "LengthFour";
229 case LengthThree: return "LengthThree";
230 case LengthTwo: return "LengthTwo";
231 case LengthOne: return "LengthOne";
232 case LengthUnknown: return "LengthUnknown";
233 }
234 return "NoLength_2_String";
235}
236
237static inline const char* p_OrdEnum_2_String(p_Ord ord)
238{
239 switch(ord)
240 {
241 case OrdGeneral: return "OrdGeneral";
242 case OrdPomog: return "OrdPomog";
243 case OrdNomog: return "OrdNomog";
244 case OrdNegPomog: return "OrdNegPomog";
245 case OrdPomogNeg: return "OrdPomogNeg";
246 case OrdPosNomog: return "OrdPosNomog";
247 case OrdNomogPos: return "OrdNomogPos";
248 case OrdPosPosNomog: return "OrdPosPosNomog";
249 case OrdPosNomogPos: return "OrdPosNomogPos";
250 case OrdNegPosNomog: return "OrdNegPosNomog";
251#ifdef HAVE_LENGTH_DIFF
252 case OrdNegPomogZero: return "OrdNegPomogZero";
253 case OrdPomogNegZero: return "OrdPomogNegZero";
254 case OrdPomogZero: return "OrdPomogZero";
255 case OrdNomogZero: return "OrdNomogZero";
256 case OrdNomogPosZero: return "OrdNomogPosZero";
257 case OrdPosNomogZero: return "OrdPosNomogZero";
258 case OrdPosPosNomogZero: return "OrdPosPosNomogZero";
259 case OrdPosNomogPosZero: return "OrdPosNomogPosZero";
260 case OrdNegPosNomogZero: return "OrdNegPosNomogZero";
261#endif
262 case OrdUnknown: return "OrdUnknown";
263 }
264 return "NoOrd_2_String";
265}
266
267static inline const char* p_ProcEnum_2_String(p_Proc proc)
268{
269 switch(proc)
270 {
271 case p_Copy_Proc: return "p_Copy_Proc";
272 case p_Delete_Proc: return "p_Delete_Proc";
273 case p_ShallowCopyDelete_Proc: return "p_ShallowCopyDelete_Proc";
274 case p_Mult_nn_Proc: return "p_Mult_nn_Proc";
275 case pp_Mult_nn_Proc: return "pp_Mult_nn_Proc";
276 case pp_Mult_mm_Proc: return "pp_Mult_mm_Proc";
277 case pp_Mult_mm_Noether_Proc: return "pp_Mult_mm_Noether_Proc";
278 case p_Mult_mm_Proc: return "p_Mult_mm_Proc";
279 case p_Add_q_Proc: return "p_Add_q_Proc";
280 case p_Minus_mm_Mult_qq_Proc: return "p_Minus_mm_Mult_qq_Proc";
281 case p_Neg_Proc: return "p_Neg_Proc";
282 case pp_Mult_Coeff_mm_DivSelect_Proc: return "pp_Mult_Coeff_mm_DivSelect_Proc";
283 case pp_Mult_Coeff_mm_DivSelectMult_Proc: return "pp_Mult_Coeff_mm_DivSelectMult_Proc";
284 case p_Merge_q_Proc: return "p_Merge_q_Proc";
285 case p_kBucketSetLm_Proc: return "p_kBucketSetLm_Proc";
286 case p_Unknown_Proc: return "p_Unknown_Proc";
287 }
288 return "NoProc_2_String";
289}
290
292{
295 return 0;
296 return 1;
297}
298
300{
301 switch(proc)
302 {
303 case p_Add_q_Proc:
307 case p_Merge_q_Proc:
308 return 1;
309
310 default:
311 return 0;
312 }
313}
314
316{
317 switch(proc)
318 {
319 case p_Delete_Proc:
320 case p_Mult_nn_Proc:
321 case p_Neg_Proc:
322 return 0;
323
324 default:
325 return 1;
326 }
327}
328
329// returns string specifying the module into which the p_Proc
330// should go
331static inline const char* p_ProcField_2_Module(p_Proc proc, p_Field field)
332{
334 return "FieldIndep";
335 else
336 {
337 if (field > FieldQ) field = FieldGeneral;
338 return p_FieldEnum_2_String(field);
339 }
340}
341
342/***************************************************************
343 *
344 *
345 * Deal with OrdZero
346 *
347 *******************************************************************/
348#ifdef HAVE_LENGTH_DIFF
349static inline int IsZeroOrd(p_Ord ord)
350{
351 return (ord == OrdPomogZero || ord == OrdNomogZero ||
352 ord == OrdNegPomogZero || ord == OrdPosNomogZero ||
353 ord == OrdPomogNegZero || ord == OrdNomogPosZero ||
354 ord == OrdPosNomogPosZero || ord == OrdPosPosNomogZero ||
355 ord == OrdNegPosNomogZero);
356}
357
358static inline p_Ord ZeroOrd_2_NonZeroOrd(p_Ord ord, int strict)
359{
360 if (IsZeroOrd(ord))
361 {
362 switch (ord)
363 {
364 case OrdPomogZero: return OrdPomog;
365 case OrdNomogZero: return OrdNomog;
366 case OrdNegPomogZero: return OrdNegPomog;
367 case OrdPosNomogZero: return OrdPosNomog;
370 default:
371 if (strict) return OrdGeneral;
372 else if (ord == OrdPomogNegZero) return OrdPomogNeg;
373 else if (ord == OrdNomogPosZero) return OrdNomogPos;
374 else if (ord == OrdPosNomogPosZero) return OrdPosNomogPos;
375 else return OrdGeneral;
376 }
377 }
378 else
379 {
380 return ord;
381 }
382}
383#else
384#define IsZeroOrd(ord) 0
385#define ZeroOrd_2_NonZeroOrd(ord) (ord)
386#endif
387
388/***************************************************************
389 *
390 * Filters which are applied to field/length/ord, before a proc is
391 * chosen
392 *
393 *******************************************************************/
394#ifdef p_Procs_Static
395static inline void StaticKernelFilter(p_Field &field, p_Length &length,
396 p_Ord &ord, const p_Proc proc)
397{
398 // simply exclude some things
400 (field != RingGeneral) &&
401 (field != FieldZp))
402 {
403 field = FieldGeneral;
405 ord = OrdGeneral;
406 }
407}
408#endif
409
410static inline void FastP_ProcsFilter(p_Field &field, p_Length &length, p_Ord &ord, const p_Proc proc)
411{
412 if (HAVE_FAST_P_PROCS >= 5) return;
413
414 if (HAVE_FAST_P_PROCS < 3 && field == FieldQ)
415 field = FieldGeneral;
416
417 if ((HAVE_FAST_P_PROCS == 0) ||
418 (HAVE_FAST_P_PROCS <= 4 && field != FieldZp && field != FieldQ &&
420 {
421 if (field != RingGeneral) field = FieldGeneral;
423 ord = OrdGeneral;
424 return;
425 }
426 if (HAVE_FAST_P_PROCS == 1 ||
427 (HAVE_FAST_P_PROCS == 4 && field != FieldZp && proc != p_Merge_q_Proc))
428 ord = OrdGeneral;
429}
430
431static inline void FastFieldFilter(p_Field &field)
432{
433 if (HAVE_FAST_FIELD <= 0 ||
434 (HAVE_FAST_FIELD == 1 && field != FieldZp) ||
435 (field != FieldZp && field != FieldQ))
436 if (field != RingGeneral) field = FieldGeneral;
437}
438
439static inline void FastLengthFilter(p_Length &length)
440{
441 if ((HAVE_FAST_LENGTH == 3 && length <= LengthFive) ||
442 (HAVE_FAST_LENGTH == 2 && length <= LengthFour) ||
443 (HAVE_FAST_LENGTH == 1 && length <= LengthTwo) ||
444 (HAVE_FAST_LENGTH <= 0))
445 {
447 }
448}
449
450static inline void FastOrdFilter(p_Ord &ord)
451{
452 if ((HAVE_FAST_ORD == 3 && ord >= OrdNomogPosZero) ||
453 (HAVE_FAST_ORD == 2 && ord >= OrdPosNomog) ||
454 (HAVE_FAST_ORD == 1 && ord >= OrdPomogZero) ||
455 (HAVE_FAST_ORD <= 0))
456 ord = OrdGeneral;
457}
458
459static inline void FastOrdZeroFilter(p_Ord &ord)
460{
461 if (IsZeroOrd(ord))
462 {
463 if ((HAVE_FAST_ZERO_ORD == 1 && (ord != OrdPosNomogPosZero &&
464 ord != OrdNomogPosZero &&
465 ord != OrdPomogNegZero)) ||
466 (HAVE_FAST_ZERO_ORD <= 0))
467 ord = ZeroOrd_2_NonZeroOrd(ord, 1);
468 }
469}
470
471static inline void NCopy__Filter(p_Field &field)
472{
473 if (ZP_COPY_FIELD(field)) field = FieldZp;
474 else if (field == RingGeneral) field = FieldGeneral;
475}
476
477// in p_Add_q, p_MemCmp works with CompLSize,
478// hence, we do not need to consider ZeroOrds
479static inline void p_Add_q__Filter(p_Field &field,p_Length &length, p_Ord &ord)
480{
481 if (IsZeroOrd(ord))
482 {
483 ord = ZeroOrd_2_NonZeroOrd(ord, 0);
484 if (length > LengthGeneral)
485 {
486 length = (p_Length) ((int)length + 1);
487 }
488 }
489 if (field == RingGeneral) field = FieldGeneral;
490}
491
492static inline void p_Neg__Filter(p_Field &field,p_Length &length, p_Ord &ord)
493{
494 if (field == RingGeneral) field = FieldGeneral;
496 ord =OrdGeneral;
497}
498
499static inline void pp_Mult_mm_Noether_Filter(p_Field &field,
500 p_Length &length, p_Ord &ord)
501{
502 if (ord == OrdPomog
503 || ord == OrdPomogZero
504 || (ord == OrdPomogNeg && length > LengthTwo)
505#ifdef HAVE_LENGTH_DIFF
506 || (ord == OrdPomogZero)
507 || (ord == OrdPomogNegZero && length > LengthThree)
508#endif
509 )
510 {
511 // all the other orderings might occur (remember Mixed Orderings!)
512 if (field != RingGeneral) field = FieldGeneral;
513 ord = OrdGeneral;
515 }
516}
517
518static inline void FastProcFilter(p_Proc proc, p_Field &field,
519 p_Length &length, p_Ord &ord)
520{
521 switch(proc)
522 {
523 case p_Add_q_Proc:
524 case p_Merge_q_Proc:
525 p_Add_q__Filter(field, length, ord);
526 break;
527
528 case p_Neg_Proc:
529 p_Neg__Filter(field, length, ord);
530 break;
531
532 case p_Copy_Proc:
533 case p_Delete_Proc:
534 NCopy__Filter(field);
535 break;
536
539 break;
540
542 if (length == LengthOne || length == LengthTwo)
543 {
544 if (field != RingGeneral) field = FieldGeneral;
546 ord = OrdGeneral;
547 return;
548 }
549 break;
550
551 default: break;
552 }
553
554 FastOrdFilter(ord);
557 FastFieldFilter(field);
558 FastP_ProcsFilter(field, length, ord, proc);
559#ifdef p_Procs_Static
560 StaticKernelFilter(field, length, ord, proc);
561#endif
562}
563
564// returns 0 if combination of field/length/ord is invalid
565static inline int IsValidSpec(p_Field field, p_Length length, p_Ord ord)
566{
567 if (field == FieldUnknown || length == LengthUnknown || ord == OrdUnknown)
568 return 0;
569
570 if (length >= LengthThree && // i.e. 1, 2, or 3
571 ord > ORD_MAX_N_3) // i.e. OrdNomogPosZero and below
572 return 0;
573
574 if (length >= LengthTwo && // i.e. 1 or 2
575 ord > ORD_MAX_N_2) // i.e. PosNomog and below
576 return 0;
577
578 if (length == LengthOne &&
579 ord > ORD_MAX_N_1) // i.e. PosPomogZero and below
580 return 0;
581
582 // we cover everything for length <= two
583 if (ord == OrdGeneral && length > LengthTwo)
584 return 0;
585#ifndef HAVE_RINGS
586 if (field == RingGeneral) return 0;
587#endif
588 return 1;
589}
590
591
592static inline int index(p_Length length, p_Ord ord)
593{
594 return length*OrdUnknown + ord;
595}
596
597static inline int index(p_Field field, p_Length length)
598{
599 return field*LengthUnknown + length;
600}
601
602static inline int index(p_Field field, p_Length length, p_Ord ord)
603{
604 return field*LengthUnknown*OrdUnknown + length*OrdUnknown + ord;
605}
606
607static inline int index(p_Proc proc, p_Field field, p_Length length, p_Ord ord)
608{
609 switch(proc)
610 {
611 case p_Delete_Proc:
612 case p_Mult_nn_Proc:
613 case p_Neg_Proc:
614 return field;
615
617 return length;
618
619 case p_Copy_Proc:
620 case pp_Mult_mm_Proc:
621 case p_Mult_mm_Proc:
622 case pp_Mult_nn_Proc:
625 return index(field, length);
626
627 case p_Add_q_Proc:
631 return index(field, length, ord);
632
633 case p_Merge_q_Proc:
634 return index(length, ord);
635
636 default:
637 printf("error in index (%d)- should not happen", (int)proc);
638 return -1;
639 }
640}
641
642
643
644/***************************************************************
645 *
646 * Macros for setting procs -- these are used for
647 * generation and setting
648 *
649 ***************************************************************/
650
651#define SetProc(what, field, length, ord) \
652do \
653{ \
654 p_Field t_field = field; \
655 p_Ord t_ord = ord; \
656 p_Length t_length = length; \
657 FastProcFilter(what##_Proc, t_field, t_length, t_ord); \
658 DoSetProc(what, t_field, t_length, t_ord); \
659} \
660while (0) \
661
662#define SetProcs(field, length, ord) \
663do \
664{ \
665 SetProc(p_Copy, field, length, OrdGeneral); \
666 SetProc(p_Delete, field, LengthGeneral, OrdGeneral); \
667 SetProc(p_ShallowCopyDelete, FieldGeneral, length, OrdGeneral); \
668 SetProc(p_Mult_nn, field, LengthGeneral, OrdGeneral); \
669 SetProc(pp_Mult_nn, field, length, OrdGeneral); \
670 SetProc(pp_Mult_mm, field, length, OrdGeneral); \
671 SetProc(p_Mult_mm, field, length, OrdGeneral); \
672 SetProc(p_Minus_mm_Mult_qq, field, length, ord); \
673 SetProc(pp_Mult_mm_Noether, field, length, ord); \
674 SetProc(p_Add_q, field, length, ord); \
675 SetProc(p_Neg, field, LengthGeneral, OrdGeneral); \
676 SetProc(pp_Mult_Coeff_mm_DivSelect, field, length, OrdGeneral); \
677 SetProc(pp_Mult_Coeff_mm_DivSelectMult, field, length, OrdGeneral); \
678 SetProc(p_Merge_q, FieldGeneral, length, ord); \
679 SetProc(p_kBucketSetLm, field, length, ord); \
680} \
681while (0)
682
683#ifdef NV_OPS
684#define SetProcs_nv(field, length, ord) \
685do \
686{ \
687 SetProc(p_Delete, field, LengthGeneral, OrdGeneral); \
688 SetProc(p_ShallowCopyDelete, FieldGeneral, length, OrdGeneral); \
689 SetProc(p_Copy, field, length, OrdGeneral); \
690 SetProc(p_Add_q, field, length, ord); \
691 SetProc(p_kBucketSetLm, field, length, ord); \
692 SetProc(p_Neg, field, LengthGeneral, OrdGeneral); \
693 SetProc(p_Merge_q, FieldGeneral, length, ord); \
694} \
695while (0)
696#endif
697
698#define SetProcs_ring(field, length, ord) \
699do \
700{ \
701 SetProc(p_Copy, FieldGeneral, length, OrdGeneral); \
702 SetProc(p_Delete, FieldGeneral, LengthGeneral, OrdGeneral); \
703 SetProc(p_ShallowCopyDelete, FieldGeneral, length, OrdGeneral); \
704 SetProc(p_Add_q, FieldGeneral, length, ord); \
705 SetProc(p_Neg, FieldGeneral, LengthGeneral, OrdGeneral); \
706 SetProc(p_Merge_q, FieldGeneral, length, ord); \
707 SetProc(p_Mult_nn, field, LengthGeneral, OrdGeneral); \
708 SetProc(pp_Mult_nn, field, LengthGeneral, OrdGeneral); \
709 SetProc(pp_Mult_mm, field, length, OrdGeneral); \
710 SetProc(p_Mult_mm, field, length, OrdGeneral); \
711 SetProc(p_Minus_mm_Mult_qq, field, length, ord); \
712 SetProc(pp_Mult_mm_Noether, field, length, ord); \
713 SetProc(pp_Mult_Coeff_mm_DivSelect, field, length, OrdGeneral); \
714 SetProc(pp_Mult_Coeff_mm_DivSelectMult, field, length, OrdGeneral); \
715} \
716while (0)
717
718#endif // P_PROCS_IMPL_H
719
All the auxiliary stuff.
unsigned char * proc[NUM_PROC]
Definition: checklibs.c:16
static BOOLEAN length(leftv result, leftv arg)
Definition: interval.cc:257
#define ORD_MAX_N_2
Definition: p_Procs_Impl.h:151
static int p_ProcDependsOn_Ord(p_Proc proc)
Definition: p_Procs_Impl.h:299
p_Length
Definition: p_Procs_Impl.h:123
@ LengthFive
Definition: p_Procs_Impl.h:128
@ LengthUnknown
Definition: p_Procs_Impl.h:133
@ LengthFour
Definition: p_Procs_Impl.h:129
@ LengthThree
Definition: p_Procs_Impl.h:130
@ LengthEight
Definition: p_Procs_Impl.h:125
@ LengthSix
Definition: p_Procs_Impl.h:127
@ LengthGeneral
Definition: p_Procs_Impl.h:124
@ LengthOne
Definition: p_Procs_Impl.h:132
@ LengthSeven
Definition: p_Procs_Impl.h:126
@ LengthTwo
Definition: p_Procs_Impl.h:131
static void FastOrdZeroFilter(p_Ord &ord)
Definition: p_Procs_Impl.h:459
static int index(p_Length length, p_Ord ord)
Definition: p_Procs_Impl.h:592
static int p_ProcDependsOn_Field(p_Proc proc)
Definition: p_Procs_Impl.h:291
static void p_Neg__Filter(p_Field &field, p_Length &length, p_Ord &ord)
Definition: p_Procs_Impl.h:492
#define HAVE_LENGTH_DIFF
Definition: p_Procs_Impl.h:88
static const char * p_ProcField_2_Module(p_Proc proc, p_Field field)
Definition: p_Procs_Impl.h:331
p_Field
Definition: p_Procs_Impl.h:107
@ FieldUnknown
Definition: p_Procs_Impl.h:120
@ FieldQ
Definition: p_Procs_Impl.h:110
@ FieldZp
Definition: p_Procs_Impl.h:109
@ RingGeneral
Definition: p_Procs_Impl.h:119
@ FieldZp_a
Definition: p_Procs_Impl.h:116
@ FieldQ_a
Definition: p_Procs_Impl.h:117
@ FieldLong_R
Definition: p_Procs_Impl.h:114
@ FieldLong_C
Definition: p_Procs_Impl.h:115
@ FieldR
Definition: p_Procs_Impl.h:111
@ FieldGeneral
Definition: p_Procs_Impl.h:108
@ FieldGF
Definition: p_Procs_Impl.h:112
#define HAVE_FAST_LENGTH
Definition: p_Procs_Impl.h:66
static void pp_Mult_mm_Noether_Filter(p_Field &field, p_Length &length, p_Ord &ord)
Definition: p_Procs_Impl.h:499
static void FastFieldFilter(p_Field &field)
Definition: p_Procs_Impl.h:431
static int IsZeroOrd(p_Ord ord)
Definition: p_Procs_Impl.h:349
#define HAVE_FAST_P_PROCS
Definition: p_Procs_Impl.h:47
static int p_ProcDependsOn_Length(p_Proc proc)
Definition: p_Procs_Impl.h:315
p_Proc
Definition: p_Procs_Impl.h:179
@ p_ShallowCopyDelete_Proc
Definition: p_Procs_Impl.h:182
@ p_Delete_Proc
Definition: p_Procs_Impl.h:181
@ p_kBucketSetLm_Proc
Definition: p_Procs_Impl.h:194
@ p_Neg_Proc
Definition: p_Procs_Impl.h:190
@ p_Mult_nn_Proc
Definition: p_Procs_Impl.h:183
@ p_Mult_mm_Proc
Definition: p_Procs_Impl.h:187
@ pp_Mult_nn_Proc
Definition: p_Procs_Impl.h:184
@ pp_Mult_Coeff_mm_DivSelect_Proc
Definition: p_Procs_Impl.h:191
@ p_Merge_q_Proc
Definition: p_Procs_Impl.h:193
@ p_Copy_Proc
Definition: p_Procs_Impl.h:180
@ p_Add_q_Proc
Definition: p_Procs_Impl.h:188
@ pp_Mult_mm_Proc
Definition: p_Procs_Impl.h:185
@ pp_Mult_Coeff_mm_DivSelectMult_Proc
Definition: p_Procs_Impl.h:192
@ p_Minus_mm_Mult_qq_Proc
Definition: p_Procs_Impl.h:189
@ pp_Mult_mm_Noether_Proc
Definition: p_Procs_Impl.h:186
@ p_Unknown_Proc
Definition: p_Procs_Impl.h:195
static void FastP_ProcsFilter(p_Field &field, p_Length &length, p_Ord &ord, const p_Proc proc)
Definition: p_Procs_Impl.h:410
#define HAVE_FAST_ZERO_ORD
Definition: p_Procs_Impl.h:84
#define ZP_COPY_FIELD(field)
Definition: p_Procs_Impl.h:93
static const char * p_FieldEnum_2_String(p_Field field)
Definition: p_Procs_Impl.h:198
static p_Ord ZeroOrd_2_NonZeroOrd(p_Ord ord, int strict)
Definition: p_Procs_Impl.h:358
#define ORD_MAX_N_1
Definition: p_Procs_Impl.h:142
static void NCopy__Filter(p_Field &field)
Definition: p_Procs_Impl.h:471
#define HAVE_FAST_FIELD
Definition: p_Procs_Impl.h:56
p_Ord
Definition: p_Procs_Impl.h:136
@ OrdNomogZero
Definition: p_Procs_Impl.h:146
@ OrdPomogNegZero
Definition: p_Procs_Impl.h:158
@ OrdPosNomog
Definition: p_Procs_Impl.h:153
@ OrdNegPomogZero
Definition: p_Procs_Impl.h:157
@ OrdPosNomogPosZero
Definition: p_Procs_Impl.h:171
@ OrdNegPomog
Definition: p_Procs_Impl.h:149
@ OrdPomogNeg
Definition: p_Procs_Impl.h:150
@ OrdPomog
Definition: p_Procs_Impl.h:140
@ OrdUnknown
Definition: p_Procs_Impl.h:175
@ OrdPosNomogZero
Definition: p_Procs_Impl.h:168
@ OrdPosPosNomogZero
Definition: p_Procs_Impl.h:170
@ OrdPosNomogPos
Definition: p_Procs_Impl.h:162
@ OrdGeneral
Definition: p_Procs_Impl.h:137
@ OrdNomog
Definition: p_Procs_Impl.h:141
@ OrdNegPosNomogZero
Definition: p_Procs_Impl.h:172
@ OrdNomogPos
Definition: p_Procs_Impl.h:154
@ OrdPomogZero
Definition: p_Procs_Impl.h:145
@ OrdPosPosNomog
Definition: p_Procs_Impl.h:161
@ OrdNegPosNomog
Definition: p_Procs_Impl.h:163
@ OrdNomogPosZero
Definition: p_Procs_Impl.h:167
static void p_Add_q__Filter(p_Field &field, p_Length &length, p_Ord &ord)
Definition: p_Procs_Impl.h:479
static const char * p_OrdEnum_2_String(p_Ord ord)
Definition: p_Procs_Impl.h:237
static void FastLengthFilter(p_Length &length)
Definition: p_Procs_Impl.h:439
static const char * p_LengthEnum_2_String(p_Length length)
Definition: p_Procs_Impl.h:219
static void FastOrdFilter(p_Ord &ord)
Definition: p_Procs_Impl.h:450
static void FastProcFilter(p_Proc proc, p_Field &field, p_Length &length, p_Ord &ord)
Definition: p_Procs_Impl.h:518
#define HAVE_FAST_ORD
Definition: p_Procs_Impl.h:76
static const char * p_ProcEnum_2_String(p_Proc proc)
Definition: p_Procs_Impl.h:267
#define ORD_MAX_N_3
Definition: p_Procs_Impl.h:164
static int IsValidSpec(p_Field field, p_Length length, p_Ord ord)
Definition: p_Procs_Impl.h:565