Context Navigation

source: git/kernel/p_Procs_Impl.h @ 35aab3

spielwiese

Last change on this file since 35aab3 was 35aab3, checked in by Hans Schönemann <hannes@…>, 21 years ago
This commit was generated by cvs2svn to compensate for changes in r6879, which included commits to RCS files with non-trunk default branches. git-svn-id: file:///usr/local/Singular/svn/trunk@6880 2c84dea3-7e68-4137-9b89-c4e89433aadc
Property mode set to `100644`
File size: 19.7 KB

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

Note: See TracBrowser for help on using the repository browser.

Download in other formats: