56 WORD execarg(
PHEAD WORD *term, WORD level)
60 WORD *start, *stop, *rstop, *r1, *r2 = 0, *r3 = 0, *r4, *r5, *r6, *r7, *r8, *r9;
61 WORD *mm, *mstop, *rnext, *rr, *factor, type, ngcd, nq;
62 CBUF *C = cbuf+AM.rbufnum, *CC = cbuf+AT.ebufnum;
63 WORD i, j, k, oldnumlhs = AR.Cnumlhs, count, action = 0, olddefer = AR.DeferFlag;
64 WORD oldnumrhs = CC->numrhs, size, pow, jj;
65 LONG oldcpointer = CC->Pointer - CC->Buffer, oldppointer = AT.pWorkPointer, lp;
66 WORD *oldwork = AT.WorkPointer, *oldwork2, scale, renorm;
67 WORD kLCM = 0, kGCD = 0, kGCD2, kkLCM = 0, jLCM = 0, jGCD, sign = 1;
69 UWORD *EAscrat, *GCDbuffer, *GCDbuffer2, *LCMbuffer, *LCMb, *LCMc;
70 AT.WorkPointer += *term;
71 start = C->
lhs[level];
72 AR.Cnumlhs = start[2];
73 stop = start + start[1];
77 start += TYPEARGHEADSIZE;
81 if ( renorm && start[1] != 0 ) {
82 t = start+1; factor = oldwork2 = v = AT.WorkPointer;
84 *v++ = i+3; i--; NCOPY(v,t,i);
85 *v++ = 1; *v++ = 1; *v++ = 3;
87 start = t; AR.Eside = LHSIDEX;
89 if (
Generator(BHEAD factor,AR.Cnumlhs) ) {
91 AT.WorkPointer = oldwork;
95 if (
EndSort(BHEAD factor,0) < 0 ) {}
96 if ( *factor && *(factor+*factor) != 0 ) {
97 MLOCK(ErrorMessageLock);
98 MesPrint(
"&$ in () does not evaluate into a single term");
99 MUNLOCK(ErrorMessageLock);
122 rstop = r - ABS(r[-1]);
127 while ( t < rstop ) {
128 if ( *t >= FUNCTION && functions[*t-FUNCTION].spec == 0 ) {
141 if ( count <= 0 ) { t += t[1];
continue; }
145 for ( i = 1; i <= count; i++ ) {
152 if ( *r == i )
goto RightNum;
169 r1 = SetElements + Sets[m[1]].first;
170 r2 = SetElements + Sets[m[1]].last;
172 if ( *r1++ == *t )
goto HaveTodo;
175 else if ( m[1] == *t )
goto HaveTodo;
191 while ( --j > 0 ) { NEXTARG(r) }
192 if ( ( type == TYPESPLITARG ) || ( type == TYPESPLITFIRSTARG )
193 || ( type == TYPESPLITLASTARG ) ) {
194 if ( *t > FUNCTION && *r > 0 ) {
196 AT.pWorkSpace[AT.pWorkPointer++] = t;
197 AT.pWorkSpace[AT.pWorkPointer++] = r;
201 else if ( type == TYPESPLITARG2 ) {
202 if ( *t > FUNCTION && *r > 0 ) {
204 AT.pWorkSpace[AT.pWorkPointer++] = t;
205 AT.pWorkSpace[AT.pWorkPointer++] = r;
209 else if ( type == TYPEFACTARG || type == TYPEFACTARG2 ) {
210 if ( *t > FUNCTION || *t == DENOMINATOR ) {
212 mm = r + ARGHEAD; mstop = r + *r;
213 if ( mm + *mm < mstop ) {
215 AT.pWorkSpace[AT.pWorkPointer++] = t;
216 AT.pWorkSpace[AT.pWorkPointer++] = r;
219 if ( *mm == 1+ABS(mstop[-1]) )
continue;
220 if ( mstop[-3] != 1 || mstop[-2] != 1
221 || mstop[-1] != 3 ) {
223 AT.pWorkSpace[AT.pWorkPointer++] = t;
224 AT.pWorkSpace[AT.pWorkPointer++] = r;
227 GETSTOP(mm,mstop); mm++;
228 if ( mm + mm[1] < mstop ) {
230 AT.pWorkSpace[AT.pWorkPointer++] = t;
231 AT.pWorkSpace[AT.pWorkPointer++] = r;
234 if ( *mm == SYMBOL && ( mm[1] > 4 ||
235 ( mm[3] != 1 && mm[3] != -1 ) ) ) {
237 AT.pWorkSpace[AT.pWorkPointer++] = t;
238 AT.pWorkSpace[AT.pWorkPointer++] = r;
241 else if ( *mm == DOTPRODUCT && ( mm[1] > 5 ||
242 ( mm[4] != 1 && mm[4] != -1 ) ) ) {
244 AT.pWorkSpace[AT.pWorkPointer++] = t;
245 AT.pWorkSpace[AT.pWorkPointer++] = r;
248 else if ( ( *mm == DELTA || *mm == VECTOR )
251 AT.pWorkSpace[AT.pWorkPointer++] = t;
252 AT.pWorkSpace[AT.pWorkPointer++] = r;
256 else if ( factor && *factor == 4 && factor[2] == 1 ) {
258 AT.pWorkSpace[AT.pWorkPointer++] = t;
259 AT.pWorkSpace[AT.pWorkPointer++] = r;
262 else if ( factor && *factor == 0
263 && ( *r == -SNUMBER && r[1] != 1 ) ) {
265 AT.pWorkSpace[AT.pWorkPointer++] = t;
266 AT.pWorkSpace[AT.pWorkPointer++] = r;
269 else if ( *r == -MINVECTOR ) {
271 AT.pWorkSpace[AT.pWorkPointer++] = t;
272 AT.pWorkSpace[AT.pWorkPointer++] = r;
278 else if ( type == TYPENORM || type == TYPENORM2 || type == TYPENORM3 || type == TYPENORM4 ) {
280 if ( *r != -SNUMBER || r[1] == 1 || r[1] == 0 )
continue;
284 if ( scale && ( factor == 0 || *factor ) ) {
288 if ( type == TYPENORM3 ) k = 1;
295 size = REDLENG(size);
297 for ( jj = 0; jj < scale; jj++ ) {
298 if ( Mully(BHEAD (UWORD *)rstop,&size,(UWORD *)(r+1),k) )
303 for ( jj = 0; jj > scale; jj-- ) {
304 if ( Divvy(BHEAD (UWORD *)rstop,&size,(UWORD *)(r+1),k) )
308 size = INCLENG(size);
309 k = size < 0 ? -size: size;
311 *term = (WORD)(rstop - term) + k;
330 if ( type == TYPENORM4 ) {
336 GCDbuffer = NumberMalloc(
"execarg");
337 GCDbuffer2 = NumberMalloc(
"execarg");
338 LCMbuffer = NumberMalloc(
"execarg");
339 LCMb = NumberMalloc(
"execarg"); LCMc = NumberMalloc(
"execarg");
347 if ( j < 0 ) sign = -1;
351 while ( ( k > 1 ) && ( r3[k-1] == 0 ) ) k--;
352 for ( kGCD = 0; kGCD < k; kGCD++ ) GCDbuffer[kGCD] = r3[kGCD];
356 while ( ( k > 1 ) && ( r3[k-1] == 0 ) ) k--;
357 for ( kLCM = 0; kLCM < k; kLCM++ ) LCMbuffer[kLCM] = r3[kLCM];
368 while ( ( k > 1 ) && ( r3[k-1] == 0 ) ) k--;
369 if ( ( ( GCDbuffer[0] == 1 ) && ( kGCD == 1 ) ) ) {
374 else if ( ( ( k != 1 ) || ( r3[0] != 1 ) ) ) {
375 if ( GcdLong(BHEAD GCDbuffer,kGCD,(UWORD *)r3,k,GCDbuffer2,&kGCD2) ) {
376 NumberFree(GCDbuffer,
"execarg");
377 NumberFree(GCDbuffer2,
"execarg");
378 NumberFree(LCMbuffer,
"execarg");
379 NumberFree(LCMb,
"execarg"); NumberFree(LCMc,
"execarg");
383 for ( ii = 0; ii < kGCD; ii++ ) GCDbuffer[ii] = GCDbuffer2[ii];
386 kGCD = 1; GCDbuffer[0] = 1;
391 while ( ( k > 1 ) && ( r3[k-1] == 0 ) ) k--;
392 if ( ( ( LCMbuffer[0] == 1 ) && ( kLCM == 1 ) ) ) {
393 for ( kLCM = 0; kLCM < k; kLCM++ )
394 LCMbuffer[kLCM] = r3[kLCM];
396 else if ( ( k != 1 ) || ( r3[0] != 1 ) ) {
397 if ( GcdLong(BHEAD LCMbuffer,kLCM,(UWORD *)r3,k,LCMb,&kkLCM) ) {
398 NumberFree(GCDbuffer,
"execarg"); NumberFree(GCDbuffer2,
"execarg");
399 NumberFree(LCMbuffer,
"execarg"); NumberFree(LCMb,
"execarg"); NumberFree(LCMc,
"execarg");
402 DivLong((UWORD *)r3,k,LCMb,kkLCM,LCMb,&kkLCM,LCMc,&jLCM);
403 MulLong(LCMbuffer,kLCM,LCMb,kkLCM,LCMc,&jLCM);
404 for ( kLCM = 0; kLCM < jLCM; kLCM++ )
405 LCMbuffer[kLCM] = LCMc[kLCM];
413 r3 = (WORD *)(GCDbuffer);
414 if ( kGCD == kLCM ) {
415 for ( jGCD = 0; jGCD < kGCD; jGCD++ )
416 r3[jGCD+kGCD] = LCMbuffer[jGCD];
419 else if ( kGCD > kLCM ) {
420 for ( jGCD = 0; jGCD < kLCM; jGCD++ )
421 r3[jGCD+kGCD] = LCMbuffer[jGCD];
422 for ( jGCD = kLCM; jGCD < kGCD; jGCD++ )
427 for ( jGCD = kGCD; jGCD < kLCM; jGCD++ )
429 for ( jGCD = 0; jGCD < kLCM; jGCD++ )
430 r3[jGCD+kLCM] = LCMbuffer[jGCD];
433 NumberFree(GCDbuffer,
"execarg"); NumberFree(GCDbuffer2,
"execarg");
434 NumberFree(LCMbuffer,
"execarg"); NumberFree(LCMb,
"execarg"); NumberFree(LCMc,
"execarg");
444 if ( scale && ( factor == 0 || *factor > 0 ) )
450 if ( scale && ( factor == 0 || *factor ) ) {
451 size = term[*term-1];
452 size = REDLENG(size);
453 if ( MulRat(BHEAD (UWORD *)rstop,size,(UWORD *)r3,k,
454 (UWORD *)rstop,&size) )
goto execargerr;
455 size = INCLENG(size);
456 k = size < 0 ? -size: size;
457 rstop[k-1] = size*sign;
458 *term = (WORD)(rstop - term) + k;
462 if ( factor && *factor >= 1 ) {
467 r3 = r2 - ABS(r2[-1]);
470 if ( j != *r5 ) { r1 = r2;
continue; }
473 if ( *r5 != *r6 )
break;
476 if ( j > 0 ) { r1 = r2;
continue; }
479 if ( r1 >= r4 )
continue;
484 r3 = r2 - ABS(r2[-1]);
486 if ( *r3 == 1 && r3[1] == 1 ) {
487 if ( r2[-1] == 3 )
continue;
488 if ( r2[-1] == -3 && type == TYPENORM3 )
continue;
495 if ( type == TYPENORM && scale && ( factor == 0 || *factor ) ) {
500 size = term[*term-1];
501 size = REDLENG(size);
503 for ( jj = 0; jj < scale; jj++ ) {
504 if ( MulRat(BHEAD (UWORD *)rstop,size,(UWORD *)r3,k,
505 (UWORD *)rstop,&size) )
goto execargerr;
509 for ( jj = 0; jj > scale; jj-- ) {
510 if ( DivRat(BHEAD (UWORD *)rstop,size,(UWORD *)r3,k,
511 (UWORD *)rstop,&size) )
goto execargerr;
514 size = INCLENG(size);
515 k = size < 0 ? -size: size;
516 rstop[k-1] = size*sign;
517 *term = (WORD)(rstop - term) + k;
524 r4 = AddRHS(AT.ebufnum,1);
525 while ( (r4+j+12) > CC->Top ) r4 = DoubleCbuffer(AT.ebufnum,r4);
528 for ( k = 0; k < i; k++ ) *r4++ = r3[i+k];
529 for ( k = 0; k < i; k++ ) *r4++ = r3[k];
530 if ( ( type == TYPENORM3 ) || ( type == TYPENORM4 ) ) *r4++ = j*sign;
531 else *r4++ = r3[j-1];
533 CC->rhs[CC->numrhs+1] = r4;
535 AT.mulpat[5] = CC->numrhs;
536 AT.mulpat[7] = AT.ebufnum;
548 while ( --j >= 0 ) *m++ = *r++;
554 if ( type == TYPENORM || type == TYPENORM2 || type == TYPENORM3 || type == TYPENORM4 ) {
555 if ( MultDo(BHEAD r1,AT.mulpat) )
goto execargerr;
556 AT.WorkPointer = r1 + *r1;
558 if (
Generator(BHEAD r1,level) )
goto execargerr;
563 r2 = r + (( *r <= -FUNCTION ) ? 1:2);
567 AT.WorkPointer = r1 + *r1;
573 if ( type == TYPENORM || type == TYPENORM2 || type == TYPENORM3 || type == TYPENORM4 ) {
574 if ( MultDo(BHEAD m,AT.mulpat) )
goto execargerr;
575 AT.WorkPointer = m + *m;
577 if (
Generator(BHEAD m,level) )
goto execargerr;
580 if (
EndSort(BHEAD AT.WorkPointer+ARGHEAD,1) < 0 )
goto execargerr;
581 AR.DeferFlag = olddefer;
585 m = AT.WorkPointer+ARGHEAD;
586 while ( *m ) m += *m;
587 k = WORDDIF(m,AT.WorkPointer);
589 AT.WorkPointer[1] = 0;
590 if ( ToFast(AT.WorkPointer,AT.WorkPointer) ) {
591 if ( *AT.WorkPointer <= -FUNCTION ) k = 1;
595 if ( *r3 > 0 ) j = k - *r3;
596 else if ( *r3 <= -FUNCTION ) j = k - 1;
604 while ( m > AT.WorkPointer ) *--r = *--m;
608 while ( m > r2 ) *--r = *--m;
613 while ( r2 < r1 ) *r++ = *r2++;
620 CC->numrhs = oldnumrhs;
621 CC->Pointer = CC->Buffer + oldcpointer;
630 if ( ( type == TYPESPLITARG || type == TYPESPLITARG2
631 || type == TYPESPLITFIRSTARG || type == TYPESPLITLASTARG ) &&
632 AT.pWorkPointer > oldppointer ) {
634 r1 = AT.WorkPointer + 1;
636 while ( t < rstop ) {
637 if ( lp < AT.pWorkPointer && t == AT.pWorkSpace[lp] ) {
641 r2 = r1;
while ( t < m ) *r1++ = *t++;
645 if ( lp >= AT.pWorkPointer || t != AT.pWorkSpace[lp+1] ) {
646 if ( *t > 0 ) t[1] = 0;
647 while ( t < m ) *r1++ = *t++;
658 if ( type == TYPESPLITFIRSTARG ) {
659 r4 = r1; r5 = t; r7 = oldwork;
660 *r1++ = *t + ARGHEAD;
661 for ( i = 1; i < ARGHEAD; i++ ) *r1++ = 0;
675 if ( ToFast(r4,r4) ) {
677 if ( *r1 > -FUNCTION ) r1++;
683 *r1++ = i+ARGHEAD; *r1++ = 0;
686 if ( ToFast(r4,r4) ) {
688 if ( *r1 > -FUNCTION ) r1++;
695 else if ( type == TYPESPLITLASTARG ) {
696 r4 = r1; r5 = t; r7 = oldwork;
697 *r1++ = *t + ARGHEAD;
698 for ( i = 1; i < ARGHEAD; i++ ) *r1++ = 0;
712 if ( ToFast(r4,r4) ) {
714 if ( *r1 > -FUNCTION ) r1++;
720 *r1++ = i+ARGHEAD; *r1++ = 0;
723 if ( ToFast(r4,r4) ) {
725 if ( *r1 > -FUNCTION ) r1++;
732 else if ( factor == 0 || ( type == TYPESPLITARG2 && *factor == 0 ) ) {
735 *r1++ = *t + ARGHEAD;
736 for ( i = 1; i < ARGHEAD; i++ ) *r1++ = 0;
738 while ( --i >= 0 ) *r1++ = *t++;
739 if ( ToFast(r4,r4) ) {
741 if ( *r1 > -FUNCTION ) r1++;
746 else if ( type == TYPESPLITARG2 ) {
751 WORD *oRepFunList = AN.RepFunList;
752 WORD *oWildMask = AT.WildMask, *oWildValue = AN.WildValue;
753 AN.WildValue = AT.locwildvalue; AT.WildMask = AT.locwildvalue+2;
755 r4 = r1; r5 = t; r7 = oldwork;
756 *r1++ = *t + ARGHEAD;
757 for ( i = 1; i < ARGHEAD; i++ ) *r1++ = 0;
760 AN.UseFindOnly = 0; oldwork2 = AT.WorkPointer;
762 AT.WorkPointer = r1+AN.RepFunNum+2;
764 if ( FindRest(BHEAD t,factor) &&
765 ( AN.UsedOtherFind || FindOnce(BHEAD t,factor) ) ) {
769 else if ( factor[0] == FUNHEAD+1 && factor[1] >= FUNCTION ) {
770 WORD *rr1 = t+1, *rr2 = t+i;
772 while ( rr1 < rr2 ) {
773 if ( *rr1 == factor[1] )
break;
787 AT.WorkPointer = oldwork2;
789 AN.RepFunList = oRepFunList;
792 if ( ToFast(r4,r4) ) {
794 if ( *r1 > -FUNCTION ) r1++;
800 *r1++ = i+ARGHEAD; *r1++ = 0;
803 if ( ToFast(r4,r4) ) {
805 if ( *r1 > -FUNCTION ) r1++;
811 AT.WildMask = oWildMask; AN.WildValue = oWildValue;
818 *r1++ = *t + ARGHEAD;
819 for ( i = 1; i < ARGHEAD; i++ ) *r1++ = 0;
822 r6 = t + *t; r6 -= ABS(r6[-1]);
823 if ( (r6 - t) == *factor ) {
825 for ( ; k > 0; k-- ) {
826 if ( t[k] != factor[k] )
break;
829 j = r3 - t; t += *t;
continue;
832 else if ( (r6 - t) == 1 && *factor == 0 ) {
833 j = r3 - t; t += *t;
continue;
840 if ( ToFast(r4,r4) ) {
842 if ( *r1 > -FUNCTION ) r1++;
847 *r1++ = *t + ARGHEAD;
848 for ( i = 1; i < ARGHEAD; i++ ) *r1++ = 0;
850 while ( --i >= 0 ) *r1++ = *t++;
851 if ( ToFast(r4,r4) ) {
853 if ( *r1 > -FUNCTION ) r1++;
864 while ( t < r ) *r1++ = *t++;
868 while ( t < r ) *r1++ = *t++;
872 while ( --i >= 0 ) *t++ = *m++;
873 if ( AT.WorkPointer < m ) AT.WorkPointer = m;
879 if ( ( type == TYPEFACTARG || type == TYPEFACTARG2 ) &&
880 AT.pWorkPointer > oldppointer ) {
882 r1 = AT.WorkPointer + 1;
884 while ( t < rstop ) {
885 if ( lp < AT.pWorkPointer && AT.pWorkSpace[lp] == t ) {
889 r2 = r1;
while ( t < m ) *r1++ = *t++;
893 if ( lp >= AT.pWorkPointer || AT.pWorkSpace[lp+1] != t ) {
894 if ( *t > 0 ) t[1] = 0;
895 while ( t < m ) *r1++ = *t++;
904 if ( factor && ( *factor == 0 && *t == -SNUMBER ) ) {
906 if ( *t == 0 ) *r1++ = *t++;
907 else { *r1++ = 1; t++; }
910 else if ( factor && *factor == 4 && factor[2] == 1 ) {
911 if ( *t == -SNUMBER ) {
912 if ( factor[3] < 0 || t[1] >= 0 ) {
913 while ( t < m ) *r1++ = *t++;
916 *r1++ = -SNUMBER; *r1++ = -1;
917 *r1++ = *t++; *r1++ = -*t++;
921 while ( t < m ) *r1++ = *t++;
922 *r1++ = -SNUMBER; *r1++ = 1;
926 else if ( *t == -MINVECTOR ) {
927 *r1++ = -VECTOR; t++; *r1++ = *t++;
928 *r1++ = -SNUMBER; *r1++ = -1;
929 *r1++ = -SNUMBER; *r1++ = 1;
937 t += ARGHEAD; r5 = t;
939 if ( r5+*r5 == r3 && factor ) {
940 if ( *factor == 0 ) {
942 r9 = r1; *r1++ = 0; *r1++ = 1;
944 *r1++ = (r6-t)+3; t++;
945 while ( t < r6 ) *r1++ = *t++;
946 *r1++ = 1; *r1++ = 1; *r1++ = 3;
948 if ( ToFast(r9,r9) ) {
949 if ( *r9 <= -FUNCTION ) r1 = r9+1;
954 if ( factor[0] == 4 && factor[2] == 1 ) {
956 r7 = r1; *r1++ = (r6-t)+3+ARGHEAD; *r1++ = 0;
958 *r1++ = (r6-t)+3; t++;
959 while ( t < r6 ) *r1++ = *t++;
960 *r1++ = 1; *r1++ = 1; *r1++ = 3;
961 if ( ToFast(r7,r7) ) {
962 if ( *r7 <= -FUNCTION ) r1 = r7+1;
965 if ( r3[-1] < 0 && factor[3] > 0 ) {
966 *r1++ = -SNUMBER; *r1++ = -1;
967 if ( r3[-1] == -3 && r3[-2] == 1
968 && ( r3[-3] & MAXPOSITIVE ) == r3[-3] ) {
969 *r1++ = -SNUMBER; *r1++ = r3[-3];
972 *r1++ = (r3-r6)+1+ARGHEAD;
976 while ( t < r3 ) *r1++ = *t++;
981 if ( ( r3[-1] == -3 || r3[-1] == 3 )
983 && ( r3[-3] & MAXPOSITIVE ) == r3[-3] ) {
984 *r1++ = -SNUMBER; *r1++ = r3[-3];
985 if ( r3[-1] < 0 ) r1[-1] = - r1[-1];
988 *r1++ = (r3-r6)+1+ARGHEAD;
992 while ( t < r3 ) *r1++ = *t++;
1006 if ( AC.OldFactArgFlag == NEWFACTARG ) {
1007 if ( factor == 0 ) {
1008 WORD *oldworkpointer2 = AT.WorkPointer;
1009 AT.WorkPointer = r1 + AM.MaxTer+FUNHEAD;
1010 if ( ArgFactorize(BHEAD t-ARGHEAD,r1) < 0 ) {
1014 AT.WorkPointer = oldworkpointer2;
1016 while ( *r1 ) { NEXTARG(r1) }
1024 t += *t;
if ( t[-1] > 0 ) { pow = 0;
break; }
1033 EAscrat = (UWORD *)(TermMalloc(
"execarg"));
1034 if ( t + *t == r3 )
goto onetermnew;
1038 while ( --i >= 0 ) EAscrat[i] = r6[i];
1043 if ( AccumGCD(BHEAD EAscrat,&ngcd,(UWORD *)r6,i) )
goto execargerr;
1044 if ( ngcd == 3 && EAscrat[0] == 1 && EAscrat[1] == 1 )
break;
1047 if ( ngcd != 3 || EAscrat[0] != 1 || EAscrat[1] != 1 ) {
1048 if ( pow ) ngcd = -ngcd;
1049 t = r5; r9 = r1; *r1++ = t[-ARGHEAD]; *r1++ = 1;
1050 FILLARG(r1); ngcd = REDLENG(ngcd);
1054 while ( r7 < r6) *r1++ = *r7++;
1057 if ( DivRat(BHEAD (UWORD *)r6,i,EAscrat,ngcd,(UWORD *)r1,&nq) )
goto execargerr;
1060 r1 += i; *r1++ = nq; *r8 = r1-r8;
1063 ngcd = INCLENG(ngcd);
1065 if ( factor && *factor == 0 ) {}
1066 else if ( ( factor && factor[0] == 4 && factor[2] == 1
1067 && factor[3] == -3 ) || pow == 0 ) {
1068 r9 = r1; *r1++ = ARGHEAD+2+i; *r1++ = 0;
1069 FILLARG(r1); *r1++ = i+2;
1070 for ( j = 0; j < i; j++ ) *r1++ = EAscrat[j];
1072 if ( ToFast(r9,r9) ) r1 = r9+2;
1074 else if ( factor && factor[0] == 4 && factor[2] == 1
1075 && factor[3] > 0 && pow ) {
1076 if ( ngcd < 0 ) ngcd = -ngcd;
1077 *r1++ = -SNUMBER; *r1++ = -1;
1078 r9 = r1; *r1++ = ARGHEAD+2+i; *r1++ = 0;
1079 FILLARG(r1); *r1++ = i+2;
1080 for ( j = 0; j < i; j++ ) *r1++ = EAscrat[j];
1082 if ( ToFast(r9,r9) ) r1 = r9+2;
1085 if ( ngcd < 0 ) ngcd = -ngcd;
1086 if ( pow ) { *r1++ = -SNUMBER; *r1++ = -1; }
1087 if ( ngcd != 3 || EAscrat[0] != 1 || EAscrat[1] != 1 ) {
1088 r9 = r1; *r1++ = ARGHEAD+2+i; *r1++ = 0;
1089 FILLARG(r1); *r1++ = i+2;
1090 for ( j = 0; j < i; j++ ) *r1++ = EAscrat[j];
1092 if ( ToFast(r9,r9) ) r1 = r9+2;
1101 if ( factor == 0 || *factor > 2 ) {
1103 *r1++ = -SNUMBER; *r1++ = -1;
1106 t += *t; t[-1] = -t[-1];
1109 t = rr; *r1++ = *t++; *r1++ = 1; t++;
1111 while ( t < m ) *r1++ = *t++;
1114 TermFree(EAscrat,
"execarg");
1123 if ( factor == 0 ) {
1128 if ( *t == SYMBOL ) {
1129 r7 = t; r8 = t + t[1]; t += 2;
1135 GETSTOP(mm,mstop); mm++;
1136 while ( mm < mstop ) {
1137 if ( *mm != SYMBOL ) mm += mm[1];
1140 if ( *mm == SYMBOL ) {
1141 mstop = mm + mm[1]; mm += 2;
1142 while ( *mm != *t && mm < mstop ) mm += 2;
1143 if ( mm >= mstop ) pow = 0;
1144 else if ( pow > 0 && mm[1] > 0 ) {
1145 if ( mm[1] < pow ) pow = mm[1];
1147 else if ( pow < 0 && mm[1] < 0 ) {
1148 if ( mm[1] > pow ) pow = mm[1];
1153 if ( pow == 0 )
break;
1156 if ( pow == 0 ) { t += 2;
continue; }
1160 action = 1; i = pow;
1162 while ( --i >= 0 ) {
1169 *r1++ = 8 + ARGHEAD;
1170 for ( j = 1; j < ARGHEAD; j++ ) *r1++ = 0;
1171 *r1++ = 8; *r1++ = SYMBOL;
1172 *r1++ = 4; *r1++ = *t; *r1++ = -1;
1173 *r1++ = 1; *r1++ = 1; *r1++ = 3;
1183 GETSTOP(mm,mstop); mm++;
1184 while ( mm < mstop ) {
1185 if ( *mm != SYMBOL ) mm += mm[1];
1188 mstop = mm + mm[1]; mm += 2;
1189 while ( mm < mstop && *mm != *t ) mm += 2;
1200 else if ( *t == DOTPRODUCT ) {
1201 r7 = t; r8 = t + t[1]; t += 2;
1207 GETSTOP(mm,mstop); mm++;
1208 while ( mm < mstop ) {
1209 if ( *mm != DOTPRODUCT ) mm += mm[1];
1212 if ( *mm == DOTPRODUCT ) {
1213 mstop = mm + mm[1]; mm += 2;
1214 while ( ( *mm != *t || mm[1] != t[1] )
1215 && mm < mstop ) mm += 3;
1216 if ( mm >= mstop ) pow = 0;
1217 else if ( pow > 0 && mm[2] > 0 ) {
1218 if ( mm[2] < pow ) pow = mm[2];
1220 else if ( pow < 0 && mm[2] < 0 ) {
1221 if ( mm[2] > pow ) pow = mm[2];
1226 if ( pow == 0 )
break;
1229 if ( pow == 0 ) { t += 3;
continue; }
1233 action = 1; i = pow;
1235 while ( --i >= 0 ) {
1236 *r1++ = 9 + ARGHEAD;
1237 for ( j = 1; j < ARGHEAD; j++ ) *r1++ = 0;
1238 *r1++ = 9; *r1++ = DOTPRODUCT;
1239 *r1++ = 5; *r1++ = *t; *r1++ = t[1]; *r1++ = 1;
1240 *r1++ = 1; *r1++ = 1; *r1++ = 3;
1245 *r1++ = 9 + ARGHEAD;
1246 for ( j = 1; j < ARGHEAD; j++ ) *r1++ = 0;
1247 *r1++ = 9; *r1++ = DOTPRODUCT;
1248 *r1++ = 5; *r1++ = *t; *r1++ = t[1]; *r1++ = -1;
1249 *r1++ = 1; *r1++ = 1; *r1++ = 3;
1259 GETSTOP(mm,mstop); mm++;
1260 while ( mm < mstop ) {
1261 if ( *mm != DOTPRODUCT ) mm += mm[1];
1264 mstop = mm + mm[1]; mm += 2;
1265 while ( mm < mstop && ( *mm != *t
1266 || mm[1] != t[1] ) ) mm += 3;
1277 else if ( *t == DELTA || *t == VECTOR ) {
1278 r7 = t; r8 = t + t[1]; t += 2;
1284 GETSTOP(mm,mstop); mm++;
1285 while ( mm < mstop ) {
1286 if ( *mm != *r7 ) mm += mm[1];
1290 mstop = mm + mm[1]; mm += 2;
1291 while ( ( *mm != *t || mm[1] != t[1] )
1292 && mm < mstop ) mm += 2;
1293 if ( mm >= mstop ) pow = 0;
1296 if ( pow == 0 )
break;
1299 if ( pow == 0 ) { t += 2;
continue; }
1304 *r1++ = 8 + ARGHEAD;
1305 for ( j = 1; j < ARGHEAD; j++ ) *r1++ = 0;
1306 *r1++ = 8; *r1++ = *r7;
1307 *r1++ = 4; *r1++ = *t; *r1++ = t[1];
1308 *r1++ = 1; *r1++ = 1; *r1++ = 3;
1315 GETSTOP(mm,mstop); mm++;
1316 while ( mm < mstop ) {
1317 if ( *mm != *r7 ) mm += mm[1];
1320 mstop = mm + mm[1]; mm += 2;
1321 while ( mm < mstop && (
1322 *mm != *t || mm[1] != t[1] ) ) mm += 2;
1323 *mm = mm[1] = NOINDEX;
1326 *t = t[1] = NOINDEX;
1334 else if ( *t == INDEX ) {
1335 r7 = t; r8 = t + t[1]; t += 2;
1341 GETSTOP(mm,mstop); mm++;
1342 while ( mm < mstop ) {
1343 if ( *mm != *r7 ) mm += mm[1];
1347 mstop = mm + mm[1]; mm += 2;
1349 && mm < mstop ) mm++;
1350 if ( mm >= mstop ) pow = 0;
1353 if ( pow == 0 )
break;
1356 if ( pow == 0 ) { t++;
continue; }
1373 if ( *t < 0 ) { *r1++ = -VECTOR; }
1374 else { *r1++ = -INDEX; }
1383 GETSTOP(mm,mstop); mm++;
1384 while ( mm < mstop ) {
1385 if ( *mm != *r7 ) mm += mm[1];
1388 mstop = mm + mm[1]; mm += 2;
1389 while ( mm < mstop &&
1390 *mm != *t ) mm += 1;
1401 else if ( *t >= FUNCTION ) {
1406 if ( *t >= FUNCTION &&
1407 functions[*t-FUNCTION].commute == 0 ) ncom = 0;
1411 while ( mm < t && ( *mm == DUMMYFUN
1412 || *mm == DUMMYTEN ) ) mm += mm[1];
1413 if ( mm < t ) { t += t[1];
continue; }
1415 mm = rnext; pow = 1;
1418 GETSTOP(mm,mstop); mm++;
1419 while ( mm < mstop ) {
1420 if ( *mm == *t && mm[1] == t[1] ) {
1421 for ( i = 2; i < t[1]; i++ ) {
1422 if ( mm[i] != t[i] )
break;
1425 { mm += mm[1];
goto nextmterm; }
1427 if ( ncom && *mm != DUMMYFUN && *mm != DUMMYTEN )
1431 if ( mm >= mstop ) pow = 0;
1432 if ( pow == 0 )
break;
1433 nextmterm: mm = mnext;
1435 if ( pow == 0 ) { t += t[1];
continue; }
1440 *r1++ = t[1] + 4 + ARGHEAD;
1441 for ( i = 1; i < ARGHEAD; i++ ) *r1++ = 0;
1443 for ( i = 0; i < t[1]; i++ ) *r1++ = t[i];
1444 *r1++ = 1; *r1++ = 1; *r1++ = 3;
1451 GETSTOP(mm,mstop); mm++;
1452 while ( mm < mstop ) {
1453 if ( *mm == *t && mm[1] == t[1] ) {
1454 for ( i = 2; i < t[1]; i++ ) {
1455 if ( mm[i] != t[i] )
break;
1458 if ( functions[*t-FUNCTION].spec > 0 )
1468 nextterm: mm = mnext;
1470 if ( functions[*t-FUNCTION].spec > 0 )
1488 t += *t;
if ( t[-1] > 0 ) { pow = 0;
break; }
1498 EAscrat = (UWORD *)(TermMalloc(
"execarg"));
1499 if ( t + *t == r3 )
goto oneterm;
1503 while ( --i >= 0 ) EAscrat[i] = r6[i];
1508 if ( AccumGCD(BHEAD EAscrat,&ngcd,(UWORD *)r6,i) )
goto execargerr;
1509 if ( ngcd == 3 && EAscrat[0] == 1 && EAscrat[1] == 1 )
break;
1512 if ( ngcd != 3 || EAscrat[0] != 1 || EAscrat[1] != 1 ) {
1513 if ( pow ) ngcd = -ngcd;
1514 t = r5; r9 = r1; *r1++ = t[-ARGHEAD]; *r1++ = 1;
1515 FILLARG(r1); ngcd = REDLENG(ngcd);
1519 while ( r7 < r6) *r1++ = *r7++;
1522 if ( DivRat(BHEAD (UWORD *)r6,i,EAscrat,ngcd,(UWORD *)r1,&nq) )
goto execargerr;
1525 r1 += i; *r1++ = nq; *r8 = r1-r8;
1528 ngcd = INCLENG(ngcd);
1530 if ( factor && *factor == 0 ) {}
1531 else if ( ( factor && factor[0] == 4 && factor[2] == 1
1532 && factor[3] == -3 ) || pow == 0 ) {
1533 r9 = r1; *r1++ = ARGHEAD+2+i; *r1++ = 0;
1534 FILLARG(r1); *r1++ = i+2;
1535 for ( j = 0; j < i; j++ ) *r1++ = EAscrat[j];
1537 if ( ToFast(r9,r9) ) r1 = r9+2;
1539 else if ( factor && factor[0] == 4 && factor[2] == 1
1540 && factor[3] > 0 && pow ) {
1541 if ( ngcd < 0 ) ngcd = -ngcd;
1542 *r1++ = -SNUMBER; *r1++ = -1;
1543 r9 = r1; *r1++ = ARGHEAD+2+i; *r1++ = 0;
1544 FILLARG(r1); *r1++ = i+2;
1545 for ( j = 0; j < i; j++ ) *r1++ = EAscrat[j];
1547 if ( ToFast(r9,r9) ) r1 = r9+2;
1550 if ( ngcd < 0 ) ngcd = -ngcd;
1551 if ( pow ) { *r1++ = -SNUMBER; *r1++ = -1; }
1552 if ( ngcd != 3 || EAscrat[0] != 1 || EAscrat[1] != 1 ) {
1553 r9 = r1; *r1++ = ARGHEAD+2+i; *r1++ = 0;
1554 FILLARG(r1); *r1++ = i+2;
1555 for ( j = 0; j < i; j++ ) *r1++ = EAscrat[j];
1557 if ( ToFast(r9,r9) ) r1 = r9+2;
1566 if ( factor == 0 || *factor > 2 ) {
1568 *r1++ = -SNUMBER; *r1++ = -1;
1571 t += *t; t[-1] = -t[-1];
1574 t = rr; *r1++ = *t++; *r1++ = 1; t++;
1576 while ( t < m ) *r1++ = *t++;
1579 TermFree(EAscrat,
"execarg");
1589 while ( t < r ) *r1++ = *t++;
1593 while ( t < r ) *r1++ = *t++;
1597 while ( --i >= 0 ) *t++ = *m++;
1598 if ( AT.WorkPointer < t ) AT.WorkPointer = t;
1603 AR.Cnumlhs = oldnumlhs;
1604 if ( action && Normalize(BHEAD term) )
goto execargerr;
1605 AT.WorkPointer = oldwork;
1606 if ( AT.WorkPointer < term + *term ) AT.WorkPointer = term + *term;
1607 AT.pWorkPointer = oldppointer;
1610 AT.WorkPointer = oldwork;
1611 AT.pWorkPointer = oldppointer;
1612 MLOCK(ErrorMessageLock);
1614 MUNLOCK(ErrorMessageLock);
1623 WORD execterm(
PHEAD WORD *term, WORD level)
1626 CBUF *C = cbuf+AM.rbufnum;
1627 WORD oldnumlhs = AR.Cnumlhs;
1628 WORD maxisat = C->lhs[level][2];
1630 WORD *oldworkpointer = AT.WorkPointer;
1632 WORD olddeferflag = AR.DeferFlag;
1635 AR.Cnumlhs = C->lhs[level][3];
1640 t1 = oldworkpointer;
1641 i = *term;
while ( --i >= 0 ) *t1++ = *term++;
1642 AT.WorkPointer = t1;
1643 if (
Generator(BHEAD oldworkpointer,level) )
goto exectermerr;
1647 if (
Generator(BHEAD term,level) )
goto exectermerr;
1650 M_free((
void *)buffer1,
"buffer in sort statement");
1653 if (
EndSort(BHEAD (WORD *)((VOID *)(&buffer1)),2) < 0 )
goto exectermerr;
1655 }
while ( AR.Cnumlhs < maxisat );
1656 AR.Cnumlhs = oldnumlhs;
1657 AR.DeferFlag = olddeferflag;
1660 t1 = oldworkpointer;
1661 i = *term;
while ( --i >= 0 ) *t1++ = *term++;
1662 AT.WorkPointer = t1;
1663 if (
Generator(BHEAD oldworkpointer,level) )
goto exectermerr;
1665 M_free(buffer1,
"buffer in term statement");
1666 AT.WorkPointer = oldworkpointer;
1669 AT.WorkPointer = oldworkpointer;
1670 AR.DeferFlag = olddeferflag;
1671 MLOCK(ErrorMessageLock);
1672 MesCall(
"execterm");
1673 MUNLOCK(ErrorMessageLock);
1682 int ArgumentImplode(
PHEAD WORD *term, WORD *thelist)
1685 WORD *liststart, *liststop, *inlist;
1686 WORD *w, *t, *tend, *tstop, *tt, *ttstop, *ttt, ncount, i;
1688 liststop = thelist + thelist[1];
1689 liststart = thelist + 2;
1692 tstop = tend - ABS(tend[-1]);
1694 while ( t < tstop ) {
1695 if ( *t >= FUNCTION ) {
1697 while ( inlist < liststop && *inlist != *t ) inlist += inlist[1];
1698 if ( inlist < liststop ) {
1699 tt = t; ttstop = t + t[1]; w = AT.WorkPointer;
1700 for ( i = 0; i < FUNHEAD; i++ ) *w++ = *tt++;
1701 while ( tt < ttstop ) {
1703 if ( *tt == -SNUMBER && tt[1] == 0 ) {
1704 ncount = 1; ttt = tt; tt += 2;
1705 while ( tt < ttstop && *tt == -SNUMBER && tt[1] == 0 ) {
1710 if ( tt < ttstop && *tt == -SNUMBER && ( tt[1] == 1 || tt[1] == -1 ) ) {
1712 *w++ = (ncount+1) * tt[1];
1716 else if ( ( tt[0] == tt[ARGHEAD] + ARGHEAD )
1717 && ( ABS(tt[tt[0]-1]) == 3 )
1718 && ( tt[tt[0]-2] == 1 )
1719 && ( tt[tt[0]-3] == 1 ) ) {
1720 i = *tt; NCOPY(w,tt,i)
1724 else if ( *tt == -SYMBOL ) {
1732 *w++ = ncount+1; *w++ = 1; *w++ = 3;
1736 else if ( *tt <= -FUNCTION ) {
1737 *w++ = ARGHEAD+FUNHEAD+4;
1743 *w++ = ncount+1; *w++ = 1; *w++ = 3;
1747 while ( ttt < tt ) *w++ = *ttt++;
1748 if ( tt < ttstop && *tt == -SNUMBER ) {
1749 *w++ = *tt++; *w++ = *tt++;
1753 else if ( *tt <= -FUNCTION ) {
1756 else if ( *tt < 0 ) {
1761 i = *tt; NCOPY(w,tt,i)
1764 AT.WorkPointer[1] = w - AT.WorkPointer;
1765 while ( tt < tend ) *w++ = *tt++;
1766 ttt = AT.WorkPointer; tt = t;
1767 while ( ttt < w ) *tt++ = *ttt++;
1768 term[0] = tt - term;
1769 AT.WorkPointer = tt;
1770 tend = tt; tstop = tt - ABS(tt[-1]);
1776 if ( Normalize(BHEAD term) )
return(-1);
1786 int ArgumentExplode(
PHEAD WORD *term, WORD *thelist)
1789 WORD *liststart, *liststop, *inlist, *old;
1790 WORD *w, *t, *tend, *tstop, *tt, *ttstop, *ttt, ncount, i;
1793 liststop = thelist + thelist[1];
1794 liststart = thelist + 2;
1797 tstop = tend - ABS(tend[-1]);
1799 while ( t < tstop ) {
1800 if ( *t >= FUNCTION ) {
1802 while ( inlist < liststop && *inlist != *t ) inlist += inlist[1];
1803 if ( inlist < liststop ) {
1804 tt = t; ttstop = t + t[1]; w = AT.WorkPointer;
1805 for ( i = 0; i < FUNHEAD; i++ ) *w++ = *tt++;
1806 while ( tt < ttstop ) {
1807 if ( *tt == -SNUMBER && tt[1] != 0 ) {
1808 if ( tt[1] < AM.MaxTer/((WORD)
sizeof(WORD)*4)
1809 && tt[1] > -(AM.MaxTer/((WORD)
sizeof(WORD)*4))
1810 && ( tt[1] > 1 || tt[1] < -1 ) ) {
1811 ncount = ABS(tt[1]);
1812 while ( ncount > 1 ) {
1813 *w++ = -SNUMBER; *w++ = 0; ncount--;
1816 if ( tt[1] < 0 ) *w++ = -1;
1822 *w++ = *tt++; *w++ = *tt++;
1825 else if ( *tt <= -FUNCTION ) {
1828 else if ( *tt < 0 ) {
1832 else if ( tt[0] == tt[ARGHEAD]+ARGHEAD ) {
1833 ttt = tt + tt[0] - 1;
1834 i = (ABS(ttt[0])-1)/2;
1836 TooMany: old = AN.currentTerm;
1837 AN.currentTerm = term;
1838 MesPrint(
"Too many arguments in output of ArgExplode");
1839 MesPrint(
"Term = %t");
1840 AN.currentTerm = old;
1843 if ( ttt[-1] != 1 )
goto NoExplode;
1845 if ( 2*x > (AT.WorkTop-w)-*term )
goto TooMany;
1847 while ( ncount > 0 ) {
1848 *w++ = -SNUMBER; *w++ = 0; ncount--;
1851 i = *tt; NCOPY(w,tt,i)
1856 i = *tt; NCOPY(w,tt,i)
1859 AT.WorkPointer[1] = w - AT.WorkPointer;
1860 while ( tt < tend ) *w++ = *tt++;
1861 ttt = AT.WorkPointer; tt = t;
1862 while ( ttt < w ) *tt++ = *ttt++;
1863 term[0] = tt - term;
1864 AT.WorkPointer = tt;
1865 tend = tt; tstop = tt - ABS(tt[-1]);
1871 if ( Normalize(BHEAD term) )
return(-1);
1897 int ArgFactorize(
PHEAD WORD *argin, WORD *argout)
1902 WORD *argfree, *argextra, *argcopy, *t, *tstop, *a, *a1, *a2;
1906 WORD startebuf = cbuf[AT.ebufnum].numrhs,oldword;
1907 WORD oldsorttype = AR.SortType, numargs;
1908 int error = 0, action = 0, i, ii, number, sign = 1;
1915 AR.SortType = SORTHIGHFIRST;
1916 if ( oldsorttype != AR.SortType ) {
1918 oldword = argin[*argin]; argin[*argin] = 0;
1922 if ( AN.ncmod != 0 ) {
1923 if ( AN.ncmod != 1 || ( (WORD)AN.cmod[0] < 0 ) ) {
1924 MLOCK(ErrorMessageLock);
1925 MesPrint(
"Factorization modulus a number, greater than a WORD not implemented.");
1926 MUNLOCK(ErrorMessageLock);
1930 MLOCK(ErrorMessageLock);
1931 MesCall(
"ArgFactorize");
1932 MUNLOCK(ErrorMessageLock);
1935 if ( !*t) { t = tstop;
continue; }
1940 EndSort(BHEAD argin+ARGHEAD,0);
1941 argin[*argin] = oldword;
1951 if ( a1[0] == -SNUMBER && ( a1[1] == 1 || a1[1] == -1 ) ) {
1952 if ( a1[1] == -1 ) { sign = -sign; a1[1] = 1; }
1954 a = t = a1+2;
while ( *t ) NEXTARG(t);
1956 t = a1; NCOPY(t,a,i);
1965 else if ( a1[0] == FUNHEAD+ARGHEAD+4 && a1[ARGHEAD] == FUNHEAD+4
1966 && a1[*a1-1] == 3 && a1[*a1-2] == 1 && a1[*a1-3] == 1
1967 && a1[ARGHEAD+1] >= FUNCTION ) {
1968 a = t = a1+*a1;
while ( *t ) NEXTARG(t);
1970 *a1 = -a1[ARGHEAD+1]; t = a1+1; NCOPY(t,a,i);
1976 if ( argfree == 0 ) {
1979 else if ( argfree[0] == ( argfree[ARGHEAD]+ARGHEAD ) ) {
1980 Normalize(BHEAD argfree+ARGHEAD);
1981 argfree[0] = argfree[ARGHEAD]+ARGHEAD;
1983 if ( ( argfree[0] == ARGHEAD+4 ) && ( argfree[ARGHEAD+3] == 3 )
1984 && ( argfree[ARGHEAD+1] == 1 ) && ( argfree[ARGHEAD+2] == 1 ) ) {
1994 t = argfree+ARGHEAD;
2001 EndSort(BHEAD argfree+ARGHEAD,0);
2002 t = argfree+ARGHEAD;
2003 while ( *t ) t += *t;
2004 *argfree = t - argfree;
2010 if ( ( number =
FindArg(BHEAD argfree) ) != 0 ) {
2011 if ( number > 0 ) t = cbuf[AT.fbufnum].rhs[number-1];
2012 else t = cbuf[AC.ffbufnum].rhs[-number-1];
2024 if ( *tstop == -SNUMBER && tstop[1] == -1 ) {
2025 sign = -sign; ii += 2;
2029 a = argout;
while ( *a ) NEXTARG(a);
2031 if ( sign == -1 ) { *a++ = -SNUMBER; *a++ = -1; *a = 0; sign = 1; }
2037 while ( ii > 0 ) { *--a1 = *--a2; ii--; }
2040 if ( *t == -SNUMBER && t[1] == -1 ) { t += 2; }
2041 else { COPY1ARG(a,t) }
2051 argcopy = TermMalloc(
"argcopy");
2052 for ( i = 0; i <= *argfree; i++ ) argcopy[i] = argfree[i];
2054 tstop = argfree + *argfree;
2057 t = argfree + ARGHEAD;
2058 while ( t < tstop ) {
2059 sumcommu += DoesCommu(t);
2062 if ( sumcommu > 1 ) {
2063 MesPrint(
"ERROR: Cannot factorize an argument with more than one noncommuting object");
2067 t = argfree + ARGHEAD;
2069 while ( t < tstop ) {
2070 if ( ( t[1] != SYMBOL ) && ( *t != (ABS(t[*t-1])+1) ) ) {
2076 t = argfree + ARGHEAD;
2077 argextra = AT.WorkPointer;
2079 while ( t < tstop ) {
2083 AR.SortType = oldsorttype;
2084 TermFree(argcopy,
"argcopy");
2085 if ( argfree != argin ) TermFree(argfree,
"argfree");
2086 MesCall(
"ArgFactorize");
2091 t += *t; argextra += *argextra;
2093 if (
EndSort(BHEAD argfree+ARGHEAD,0) ) { error = -2;
goto getout; }
2094 t = argfree + ARGHEAD;
2095 while ( *t > 0 ) t += *t;
2096 *argfree = t - argfree;
2104 while ( *a ) NEXTARG(a);
2105 if ( poly_factorize_argument(BHEAD argfree,a) < 0 ) {
2106 MesCall(
"ArgFactorize");
2115 if ( error == 0 && action ) {
2116 a1 = a; NEXTARG(a1);
2118 CBUF *C = cbuf+AC.cbufnum;
2119 CBUF *CC = cbuf+AT.ebufnum;
2120 WORD *oldworkpointer = AT.WorkPointer;
2121 WORD *argcopy2 = TermMalloc(
"argcopy2"), *a1, *a2;
2122 a1 = a; a2 = argcopy2;
2125 if ( *a1 > -FUNCTION ) *a2++ = *a1++;
2126 *a2++ = *a1++; *a2 = 0;
2131 argextra = AT.WorkPointer;
2133 while ( t < tstop ) {
2134 if ( ConvertFromPoly(BHEAD t,argextra,numxsymbol,CC->numrhs-startebuf+numxsymbol
2135 ,startebuf-numxsymbol,1) <= 0 ) {
2136 TermFree(argcopy2,
"argcopy2");
2142 AT.WorkPointer = argextra + *argextra;
2146 if (
Generator(BHEAD argextra,C->numlhs) ) {
2147 TermFree(argcopy2,
"argcopy2");
2153 AT.WorkPointer = oldworkpointer;
2154 if (
EndSort(BHEAD a2+ARGHEAD,0) ) { error = -5;
goto getout; }
2155 t = a2+ARGHEAD;
while ( *t ) t += *t;
2156 *a2 = t - a2; a2[1] = 0; ZEROARG(a2);
2157 ToFast(a2,a2); NEXTARG(a2);
2161 a2 = argcopy2; a1 = a;
2164 TermFree(argcopy2,
"argcopy2");
2168 CC->numrhs = startebuf;
2171 for ( i = 0; i <= *argcopy; i++ ) a[i] = argcopy[i];
2181 if ( error == 0 && AN.ncmod == 0 ) {
2182 if (
InsertArg(BHEAD argcopy,a,0) < 0 ) { error = -1; }
2192 for ( i = 0; i < ii; i++ ) argcopy[i] = argout[i];
2195 if ( *a1 == -SNUMBER && a1[1] < 0 ) {
2196 sign = -sign; a1[1] = -a1[1];
2198 a2 = a1+2;
while ( *a2 ) NEXTARG(a2);
2199 i = a2-a1-2; a2 = a1+2;
2203 while ( *a1 ) NEXTARG(a1);
2207 if ( *a1 > 0 && *a1 == a1[ARGHEAD]+ARGHEAD && a1[*a1-1] < 0 ) {
2208 a1[*a1-1] = -a1[*a1-1]; sign = -sign;
2210 if ( *a1 == ARGHEAD+4 && a1[ARGHEAD+1] == 1 && a1[ARGHEAD+2] == 1 ) {
2211 a2 = a1+ARGHEAD+4;
while ( *a2 ) NEXTARG(a2);
2212 i = a2-a1-ARGHEAD-4; a2 = a1+ARGHEAD+4;
2217 while ( *a1 ) NEXTARG(a1);
2225 for ( i = 0; i < ii; i++ ) *a2++ = argcopy[i];
2227 if ( sign == -1 ) { *a2++ = -SNUMBER; *a2++ = -1; sign = 1; }
2230 TermFree(argcopy,
"argcopy");
2232 if ( argfree != argin ) TermFree(argfree,
"argfree");
2233 if ( oldsorttype != AR.SortType ) {
2234 AR.SortType = oldsorttype;
2239 oldword = a[*a]; a[*a] = 0;
2250 else { NEXTARG(a); }
2254 t = argout; numargs = 0;
2258 if ( *tt == ABS(t[-1])+1+ARGHEAD && sign == -1 ) { t[-1] = -t[-1]; sign = 1; }
2259 else if ( *tt == -SNUMBER && sign == -1 ) { tt[1] = -tt[1]; sign = 1; }
2263 *t++ = -SNUMBER; *t++ = -1; *t = 0; sign = 1; numargs++;
2274 t = argout; numargs = 0;
2275 while ( *t && *t != -SNUMBER && ( *t < 0 || ( ABS(t[*t-1]) != *t-1 ) ) ) {
2280 if ( numargs > 1 ) {
2283 x[0] = argout[-FUNHEAD];
2284 x[1] = argout[-FUNHEAD+1];
2285 x[2] = argout[-FUNHEAD+2];
2286 while ( *t ) { NEXTARG(t); }
2287 argout[-FUNHEAD] = SQRTFUNCTION;
2288 argout[-FUNHEAD+1] = t-argout+FUNHEAD;
2289 argout[-FUNHEAD+2] = 0;
2290 AT.WorkPointer = t+1;
2291 Lijst = AT.WorkPointer;
2292 for ( i = 0; i < numargs; i++ ) Lijst[i] = i;
2293 AT.WorkPointer += numargs;
2294 error = Symmetrize(BHEAD argout-FUNHEAD,Lijst,numargs,1,SYMMETRIC);
2295 AT.WorkPointer = Lijst;
2296 argout[-FUNHEAD] = x[0];
2297 argout[-FUNHEAD+1] = x[1];
2298 argout[-FUNHEAD+2] = x[2];
2303 tstop = argout;
while ( *tstop ) { NEXTARG(tstop); }
2304 t = argout; number = 0;
2307 if ( *tt == -SNUMBER ) {
2308 if ( number == 0 )
break;
2310 while ( tt > argout ) { *--t = *--tt; }
2311 argout[0] = -SNUMBER; argout[1] = x[0];
2314 else if ( *tt == ABS(t[-1])+1+ARGHEAD ) {
2315 if ( number == 0 )
break;
2317 for ( i = 0; i < ii; i++ ) tstop[i] = tt[i];
2318 while ( tt > argout ) { *--t = *--tt; }
2319 for ( i = 0; i < ii; i++ ) argout[i] = tstop[i];
2348 if ( AN.ncmod != 0 )
return(0);
2349 number = FindTree(AT.fbufnum,a);
2350 if ( number >= 0 )
return(number+1);
2351 number = FindTree(AC.ffbufnum,a);
2352 if ( number >= 0 )
return(-number-1);
2374 bufnum = AT.fbufnum;
2378 else if ( par == 1 ) {
2379 bufnum = AC.ffbufnum;
2382 else {
return(-1); }
2384 AddNtoC(bufnum,*argin,argin);
2386 a = argout;
while ( *a ) NEXTARG(a);
2388 AddNtoC(bufnum,i,argout);
2390 return(InsTree(bufnum,C->numrhs));
2406 CBUF *C = cbuf + bufnum;
2408 LONG *weights = (LONG *)Malloc1(2*(C->numrhs+1)*
sizeof(LONG),
"CleanupArgCache");
2409 LONG w, whalf, *extraweights;
2410 WORD *a, *to, *from;
2412 for ( i = 1; i <= C->numrhs; i++ ) {
2413 weights[i] = ((LONG)i) * (boomlijst[i].
usage);
2418 extraweights = weights+C->numrhs+1;
2420 whalf = weights[C->numrhs/2+1];
2426 for ( i = 1; i <= C->numrhs; i++ ) {
2427 from = C->
rhs[i]; w = ((LONG)i) * (boomlijst[i].
usage);
2429 if ( i < C->numrhs-1 ) {
2434 j = C->
rhs[i+1] - from;
2439 else if ( to == from ) {
2440 to += *to + 1;
while ( *to ) NEXTARG(to); to++;
2443 a = from; a += *a+1;
while ( *a ) NEXTARG(a); a++;
2448 weights[k++] = boomlijst[i].
usage;
2458 ClearTree(AT.fbufnum);
2459 for ( i = 1; i <= k; i++ ) {
2460 InsTree(AT.fbufnum,i);
2461 boomlijst[i].
usage = weights[i];
2466 M_free(weights,
"CleanupArgCache");
2475 int ArgSymbolMerge(WORD *t1, WORD *t2)
2477 WORD *t1e = t1+t1[1];
2478 WORD *t2e = t2+t2[1];
2482 while ( t1a < t1e && t2a < t2e ) {
2483 if ( *t1a < *t2a ) {
2484 if ( t1a[1] >= 0 ) {
2486 while ( t3 < t1e ) { t3[-2] = *t3; t3[-1] = t3[1]; t3 += 2; }
2491 else if ( *t1a > *t2a ) {
2492 if ( t2a[1] >= 0 ) t2a += 2;
2495 while ( t3 > t1a ) { *t3 = t3[-2]; t3[1] = t3[-1]; t3 -= 2; }
2502 if ( t2a[1] < t1a[1] ) t1a[1] = t2a[1];
2506 while ( t2a < t2e ) {
2513 while ( t1a < t1e ) {
2514 if ( t1a[1] >= 0 ) {
2516 while ( t3 < t1e ) { t3[-2] = *t3; t3[-1] = t3[1]; t3 += 2; }
2530 int ArgDotproductMerge(WORD *t1, WORD *t2)
2532 WORD *t1e = t1+t1[1];
2533 WORD *t2e = t2+t2[1];
2537 while ( t1a < t1e && t2a < t2e ) {
2538 if ( *t1a < *t2a || ( *t1a == *t2a && t1a[1] < t2a[1] ) ) {
2539 if ( t1a[2] >= 0 ) {
2541 while ( t3 < t1e ) { t3[-3] = *t3; t3[-2] = t3[1]; t3[-1] = t3[2]; t3 += 3; }
2546 else if ( *t1a > *t2a || ( *t1a == *t2a && t1a[1] > t2a[1] ) ) {
2547 if ( t2a[2] >= 0 ) t2a += 3;
2550 while ( t3 > t1a ) { *t3 = t3[-3]; t3[1] = t3[-2]; t3[2] = t3[-1]; t3 -= 3; }
2558 if ( t2a[2] < t1a[2] ) t1a[2] = t2a[2];
2562 while ( t2a < t2e ) {
2570 while ( t1a < t1e ) {
2571 if ( t1a[2] >= 0 ) {
2573 while ( t3 < t1e ) { t3[-3] = *t3; t3[-2] = t3[1]; t3[-1] = t3[2]; t3 += 3; }
2601 WORD *t, *rnext, *r1, *r2, *r3, *r5, *r6, *r7, *r8, *r9;
2602 WORD pow, *mm, *mnext, *mstop, *argin2 = argin, *argin3 = argin, *argfree;
2605 r5 = t = argin + ARGHEAD;
2606 r3 = argin + *argin;
2620 if ( *t == DELTA || *t == VECTOR ) {
2621 r7 = t; r8 = t + t[1]; t += 2;
2627 GETSTOP(mm,mstop); mm++;
2628 while ( mm < mstop ) {
2629 if ( *mm != *r7 ) mm += mm[1];
2633 mstop = mm + mm[1]; mm += 2;
2634 while ( ( *mm != *t || mm[1] != t[1] )
2635 && mm < mstop ) mm += 2;
2636 if ( mm >= mstop ) pow = 0;
2639 if ( pow == 0 )
break;
2642 if ( pow == 0 ) { t += 2;
continue; }
2646 *r1++ = 8 + ARGHEAD;
2647 for ( j = 1; j < ARGHEAD; j++ ) *r1++ = 0;
2648 *r1++ = 8; *r1++ = *r7;
2649 *r1++ = 4; *r1++ = *t; *r1++ = t[1];
2650 *r1++ = 1; *r1++ = 1; *r1++ = 3;
2658 GETSTOP(mm,mstop); mm++;
2659 while ( mm < mstop ) {
2660 if ( *mm != *r7 ) mm += mm[1];
2663 mstop = mm + mm[1]; mm += 2;
2664 while ( mm < mstop && (
2665 *mm != *t || mm[1] != t[1] ) ) mm += 2;
2666 *mm = mm[1] = NOINDEX;
2669 *t = t[1] = NOINDEX;
2677 else if ( *t == INDEX ) {
2678 r7 = t; r8 = t + t[1]; t += 2;
2684 GETSTOP(mm,mstop); mm++;
2685 while ( mm < mstop ) {
2686 if ( *mm != *r7 ) mm += mm[1];
2690 mstop = mm + mm[1]; mm += 2;
2692 && mm < mstop ) mm++;
2693 if ( mm >= mstop ) pow = 0;
2696 if ( pow == 0 )
break;
2699 if ( pow == 0 ) { t++;
continue; }
2703 if ( *t < 0 ) { *r1++ = -VECTOR; }
2704 else { *r1++ = -INDEX; }
2714 GETSTOP(mm,mstop); mm++;
2715 while ( mm < mstop ) {
2716 if ( *mm != *r7 ) mm += mm[1];
2719 mstop = mm + mm[1]; mm += 2;
2720 while ( mm < mstop &&
2721 *mm != *t ) mm += 1;
2732 else if ( *t >= FUNCTION ) {
2737 if ( *t >= FUNCTION &&
2738 functions[*t-FUNCTION].commute == 0 ) ncom = 0;
2742 while ( mm < t && ( *mm == DUMMYFUN
2743 || *mm == DUMMYTEN ) ) mm += mm[1];
2744 if ( mm < t ) { t += t[1];
continue; }
2746 mm = rnext; pow = 1;
2749 GETSTOP(mm,mstop); mm++;
2750 while ( mm < mstop ) {
2751 if ( *mm == *t && mm[1] == t[1] ) {
2752 for ( i = 2; i < t[1]; i++ ) {
2753 if ( mm[i] != t[i] )
break;
2756 { mm += mm[1];
goto nextmterm; }
2758 if ( ncom && *mm != DUMMYFUN && *mm != DUMMYTEN )
2762 if ( mm >= mstop ) pow = 0;
2763 if ( pow == 0 )
break;
2764 nextmterm: mm = mnext;
2766 if ( pow == 0 ) { t += t[1];
continue; }
2770 *r1++ = t[1] + 4 + ARGHEAD;
2771 for ( i = 1; i < ARGHEAD; i++ ) *r1++ = 0;
2773 for ( i = 0; i < t[1]; i++ ) *r1++ = t[i];
2774 *r1++ = 1; *r1++ = 1; *r1++ = 3;
2782 GETSTOP(mm,mstop); mm++;
2783 while ( mm < mstop ) {
2784 if ( *mm == *t && mm[1] == t[1] ) {
2785 for ( i = 2; i < t[1]; i++ ) {
2786 if ( mm[i] != t[i] )
break;
2789 if ( functions[*t-FUNCTION].spec > 0 )
2799 nextterm: mm = mnext;
2801 if ( functions[*t-FUNCTION].spec > 0 )
2827 if ( *t == SYMBOL ) {
2835 *r2++ = SYMBOL; *r2++ = 2;
2837 t = rnext; rnext = rnext + *rnext;
2851 ArgSymbolMerge(r7,r8);
2864 if ( r8[1] < 0 ) { act = 1; pow += -r8[1]*(ARGHEAD+8); }
2865 else { pow += 2*r8[1]; }
2872 t = argin + ARGHEAD;
2878 if ( *t != SYMBOL ) { t += t[1];
continue; }
2879 r8 = r7+2; r9 = t + t[1]; t += 2;
2880 while ( ( t < r9 ) && ( r8 < r2 ) ) {
2882 t[1] -= r8[1]; t += 2; r8 += 2;
2896 r8 = r7+pow; i = r7[1];
2897 while ( --i >= 0 ) r8[i] = r7[i];
2901 for ( i = 0; i < r8[1]; i++ ) { *r1++ = -SYMBOL; *r1++ = *r8; }
2906 argin2 = TermMalloc(
"TakeArgContent2");
2911 r5 = argin2; *r5++ = 0; *r5++ = 0; FILLARG(r5);
2917 *r5++ = *t++ + r7[1];
2918 while ( t < r6 ) *r5++ = *t++;
2919 i = r7[1] - 2; r8 = r7+2;
2920 *r5++ = r7[0]; *r5++ = r7[1];
2921 while ( i > 0 ) { *r5++ = *r8++; *r5++ = -*r8++; i -= 2; }
2922 while ( t < rnext ) *r5++ = *t++;
2923 Normalize(BHEAD r9);
2927 *argin2 = r5-argin2;
2938 if (
EndSort(BHEAD t,0) < 0 )
goto Irreg;
2939 while ( *t ) t += *t;
2940 *argin2 = t - argin2;
2946 r8 = r7+pow; i = r7[1];
2947 while ( --i >= 0 ) r8[i] = r7[i];
2952 for ( i = 0; i < r8[1]; i++ ) { *r1++ = -SYMBOL; *r1++ = *r8; }
2955 for ( i = 0; i < -r8[1]; i++ ) {
2956 *r1++ = ARGHEAD+8; *r1++ = 0;
2958 *r1++ = 8; *r1++ = SYMBOL; *r1++ = 4; *r1++ = *r8;
2959 *r1++ = -1; *r1++ = 1; *r1++ = 1; *r1++ = 3;
2981 if ( *t == DOTPRODUCT ) {
2989 *r2++ = DOTPRODUCT; *r2++ = 2;
2991 t = rnext; rnext = rnext + *rnext;
3005 ArgDotproductMerge(r7,r8);
3018 if ( r8[2] < 0 ) { pow += -r8[2]*(ARGHEAD+9); }
3019 else { pow += r8[2]*(ARGHEAD+9); }
3027 argin3 = TermMalloc(
"TakeArgContent3");
3032 r5 = argin3; *r5++ = 0; *r5++ = 0; FILLARG(r5);
3038 *r5++ = *t++ + r7[1];
3039 while ( t < r6 ) *r5++ = *t++;
3040 i = r7[1] - 2; r8 = r7+2;
3041 *r5++ = r7[0]; *r5++ = r7[1];
3042 while ( i > 0 ) { *r5++ = *r8++; *r5++ = *r8++; *r5++ = -*r8++; i -= 3; }
3043 while ( t < rnext ) *r5++ = *t++;
3044 Normalize(BHEAD r9);
3048 *argin3 = r5-argin3;
3059 if (
EndSort(BHEAD t,0) < 0 )
goto Irreg;
3060 while ( *t ) t += *t;
3061 *argin3 = t - argin3;
3067 r8 = r7+pow; i = r7[1];
3068 while ( --i >= 0 ) r8[i] = r7[i];
3072 for ( i = ABS(r8[2]); i > 0; i-- ) {
3073 *r1++ = ARGHEAD+9; *r1++ = 0; FILLARG(r1);
3074 *r1++ = 9; *r1++ = DOTPRODUCT; *r1++ = 5; *r1++ = *r8;
3075 *r1++ = r8[1]; *r1++ = r8[2] < 0 ? -1: 1;
3076 *r1++ = 1; *r1++ = 1; *r1++ = 3;
3092 t = argin3 + ARGHEAD; pow = 1;
3098 t += *t; t[-1] = -t[-1];
3104 argfree = TermMalloc(
"TakeArgContent1");
3105 if ( AN.cmod != 0 ) {
3106 r1 =
MakeMod(BHEAD argin3,r1,argfree);
3119 if ( argin3 != argin2 ) TermFree(argin3,
"TakeArgContent3");
3120 if ( argin2 != argin ) TermFree(argin2,
"TakeArgContent2");
3123 MesPrint(
"Irregularity while sorting argument in TakeArgContent");
3124 if ( argin3 != argin2 ) TermFree(argin3,
"TakeArgContent3");
3125 if ( argin2 != argin ) TermFree(argin2,
"TakeArgContent2");
3146 UWORD *GCDbuffer, *GCDbuffer2, *LCMbuffer, *LCMb, *LCMc;
3147 WORD *r, *r1, *r2, *r3, *r4, *r5, *rnext, i, k, j;
3148 WORD kGCD, kLCM, kGCD2, kkLCM, jLCM, jGCD;
3149 GCDbuffer = NumberMalloc(
"MakeInteger");
3150 GCDbuffer2 = NumberMalloc(
"MakeInteger");
3151 LCMbuffer = NumberMalloc(
"MakeInteger");
3152 LCMb = NumberMalloc(
"MakeInteger");
3153 LCMc = NumberMalloc(
"MakeInteger");
3154 r4 = argin + *argin;
3155 r = argin + ARGHEAD;
3163 if ( k < 0 ) k = -k;
3164 while ( ( k > 1 ) && ( r3[k-1] == 0 ) ) k--;
3165 for ( kGCD = 0; kGCD < k; kGCD++ ) GCDbuffer[kGCD] = r3[kGCD];
3167 if ( k < 0 ) k = -k;
3169 while ( ( k > 1 ) && ( r3[k-1] == 0 ) ) k--;
3170 for ( kLCM = 0; kLCM < k; kLCM++ ) LCMbuffer[kLCM] = r3[kLCM];
3180 if ( k < 0 ) k = -k;
3181 while ( ( k > 1 ) && ( r3[k-1] == 0 ) ) k--;
3182 if ( ( ( GCDbuffer[0] == 1 ) && ( kGCD == 1 ) ) ) {
3187 else if ( ( ( k != 1 ) || ( r3[0] != 1 ) ) ) {
3188 if ( GcdLong(BHEAD GCDbuffer,kGCD,(UWORD *)r3,k,GCDbuffer2,&kGCD2) ) {
3189 NumberFree(GCDbuffer,
"MakeInteger");
3190 NumberFree(GCDbuffer2,
"MakeInteger");
3191 NumberFree(LCMbuffer,
"MakeInteger");
3192 NumberFree(LCMb,
"MakeInteger"); NumberFree(LCMc,
"MakeInteger");
3193 goto MakeIntegerErr;
3196 for ( i = 0; i < kGCD; i++ ) GCDbuffer[i] = GCDbuffer2[i];
3199 kGCD = 1; GCDbuffer[0] = 1;
3202 if ( k < 0 ) k = -k;
3204 while ( ( k > 1 ) && ( r3[k-1] == 0 ) ) k--;
3205 if ( ( ( LCMbuffer[0] == 1 ) && ( kLCM == 1 ) ) ) {
3206 for ( kLCM = 0; kLCM < k; kLCM++ )
3207 LCMbuffer[kLCM] = r3[kLCM];
3209 else if ( ( k != 1 ) || ( r3[0] != 1 ) ) {
3210 if ( GcdLong(BHEAD LCMbuffer,kLCM,(UWORD *)r3,k,LCMb,&kkLCM) ) {
3211 NumberFree(GCDbuffer,
"MakeInteger"); NumberFree(GCDbuffer2,
"MakeInteger");
3212 NumberFree(LCMbuffer,
"MakeInteger"); NumberFree(LCMb,
"MakeInteger"); NumberFree(LCMc,
"MakeInteger");
3213 goto MakeIntegerErr;
3215 DivLong((UWORD *)r3,k,LCMb,kkLCM,LCMb,&kkLCM,LCMc,&jLCM);
3216 MulLong(LCMbuffer,kLCM,LCMb,kkLCM,LCMc,&jLCM);
3217 for ( kLCM = 0; kLCM < jLCM; kLCM++ )
3218 LCMbuffer[kLCM] = LCMc[kLCM];
3226 r3 = (WORD *)(GCDbuffer);
3227 if ( kGCD == kLCM ) {
3228 for ( jGCD = 0; jGCD < kGCD; jGCD++ )
3229 r3[jGCD+kGCD] = LCMbuffer[jGCD];
3232 else if ( kGCD > kLCM ) {
3233 for ( jGCD = 0; jGCD < kLCM; jGCD++ )
3234 r3[jGCD+kGCD] = LCMbuffer[jGCD];
3235 for ( jGCD = kLCM; jGCD < kGCD; jGCD++ )
3240 for ( jGCD = kGCD; jGCD < kLCM; jGCD++ )
3242 for ( jGCD = 0; jGCD < kLCM; jGCD++ )
3243 r3[jGCD+kLCM] = LCMbuffer[jGCD];
3250 if ( ( j == 3 ) && ( r3[1] == 1 ) && ( (WORD)(r3[0]) > 0 ) ) {
3257 *r1++ = j+1+ARGHEAD; *r1++ = 0; FILLARG(r1);
3258 *r1++ = j+1; r2 = r3;
3259 for ( i = 0; i < k; i++ ) { *r1++ = *r2++; *r1++ = *r2++; }
3267 r2 = argfree + 2; FILLARG(r2)
3273 while ( r < r5 ) *r2++ = *r++;
3275 if ( DivRat(BHEAD (UWORD *)r5,j,GCDbuffer,k,(UWORD *)r2,&i) ) {
3276 goto MakeIntegerErr;
3280 if ( rnext[-1] < 0 ) r2[-1] = -i;
3286 argfree[0] = r2-argfree;
3291 NumberFree(LCMc,
"MakeInteger");
3292 NumberFree(LCMb,
"MakeInteger");
3293 NumberFree(LCMbuffer,
"MakeInteger");
3294 NumberFree(GCDbuffer2,
"MakeInteger");
3295 NumberFree(GCDbuffer,
"MakeInteger");
3299 MesCall(
"MakeInteger");
3317 WORD *r, *instop, *r1, *m, x, xx, ix, ip;
3319 r = argin; instop = r + *r; r += ARGHEAD;
3321 if ( r[*r-1] < 0 ) x += AN.cmod[0];
3325 argout[0] = -SNUMBER;
3334 m = argfree + ARGHEAD;
3335 while ( r < instop ) {
3336 xx = r[*r-3];
if ( r[*r-1] < 0 ) xx += AN.cmod[0];
3337 xx = (WORD)((((LONG)xx)*ix) % AN.cmod[0]);
3339 i = *r; NCOPY(m,r,i);
3340 m[-3] = xx; m[-1] = 3;
3345 *argfree = m - argfree;
3347 argfree += 2; FILLARG(argfree);
3362 LONG w, *fill, *from1, *from2;
3364 if ( number >= 4 ) {
3365 n1 = number/2; n2 = number - n1;
3372 for ( i = 0; i < n1; i++ ) extraspace[i] = weights[i];
3373 fill = weights; from1 = extraspace; from2 = weights+n1;
3374 while ( n1 > 0 && n2 > 0 ) {
3375 if ( *from1 <= *from2 ) { *fill++ = *from1++; n1--; }
3376 else { *fill++ = *from2++; n2--; }
3378 while ( n1 > 0 ) { *fill++ = *from1++; n1--; }
3383 else if ( number == 3 ) {
3384 if ( weights[0] > weights[1] ) {
3385 if ( weights[1] > weights[2] ) {
3386 w = weights[0]; weights[0] = weights[2]; weights[2] = w;
3388 else if ( weights[0] > weights[2] ) {
3389 w = weights[0]; weights[0] = weights[1];
3390 weights[1] = weights[2]; weights[2] = w;
3393 w = weights[0]; weights[0] = weights[1]; weights[1] = w;
3396 else if ( weights[0] > weights[2] ) {
3397 w = weights[0]; weights[0] = weights[2];
3398 weights[2] = weights[1]; weights[1] = w;
3400 else if ( weights[1] > weights[2] ) {
3401 w = weights[1]; weights[1] = weights[2]; weights[2] = w;
3404 else if ( number == 2 ) {
3405 if ( weights[0] > weights[1] ) {
3406 w = weights[0]; weights[0] = weights[1]; weights[1] = w;
int CleanupArgCache(PHEAD WORD bufnum)
WORD * MakeInteger(PHEAD WORD *argin, WORD *argout, WORD *argfree)
int LocalConvertToPoly(PHEAD WORD *, WORD *, WORD, WORD)
int GetModInverses(WORD, WORD, WORD *, WORD *)
WORD StoreTerm(PHEAD WORD *)
WORD * TakeArgContent(PHEAD WORD *argin, WORD *argout)
void SortWeights(LONG *weights, LONG *extraspace, WORD number)
WORD InsertArg(PHEAD WORD *argin, WORD *argout, int par)
WORD FindArg(PHEAD WORD *a)
WORD Generator(PHEAD WORD *, WORD)
WORD * MakeMod(PHEAD WORD *argin, WORD *argout, WORD *argfree)
LONG EndSort(PHEAD WORD *, int)