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 = 0, *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 ) {
281 if ( *r == -MINVECTOR ) { rone = -1; *r = -INDEX; }
282 else if ( *r != -SNUMBER || r[1] == 1 || r[1] == 0 )
continue;
283 else { rone = r[1]; r[1] = 1; }
287 if ( scale && ( factor == 0 || *factor ) ) {
291 if ( type == TYPENORM3 ) k = 1;
298 size = REDLENG(size);
300 for ( jj = 0; jj < scale; jj++ ) {
301 if ( Mully(BHEAD (UWORD *)rstop,&size,(UWORD *)(&rone),k) )
306 for ( jj = 0; jj > scale; jj-- ) {
307 if ( Divvy(BHEAD (UWORD *)rstop,&size,(UWORD *)(&rone),k) )
311 size = INCLENG(size);
312 k = size < 0 ? -size: size;
314 *term = (WORD)(rstop - term) + k;
332 if ( type == TYPENORM4 ) {
338 GCDbuffer = NumberMalloc(
"execarg");
339 GCDbuffer2 = NumberMalloc(
"execarg");
340 LCMbuffer = NumberMalloc(
"execarg");
341 LCMb = NumberMalloc(
"execarg"); LCMc = NumberMalloc(
"execarg");
349 if ( j < 0 ) sign = -1;
353 while ( ( k > 1 ) && ( r3[k-1] == 0 ) ) k--;
354 for ( kGCD = 0; kGCD < k; kGCD++ ) GCDbuffer[kGCD] = r3[kGCD];
358 while ( ( k > 1 ) && ( r3[k-1] == 0 ) ) k--;
359 for ( kLCM = 0; kLCM < k; kLCM++ ) LCMbuffer[kLCM] = r3[kLCM];
370 while ( ( k > 1 ) && ( r3[k-1] == 0 ) ) k--;
371 if ( ( ( GCDbuffer[0] == 1 ) && ( kGCD == 1 ) ) ) {
376 else if ( ( ( k != 1 ) || ( r3[0] != 1 ) ) ) {
377 if ( GcdLong(BHEAD GCDbuffer,kGCD,(UWORD *)r3,k,GCDbuffer2,&kGCD2) ) {
378 NumberFree(GCDbuffer,
"execarg");
379 NumberFree(GCDbuffer2,
"execarg");
380 NumberFree(LCMbuffer,
"execarg");
381 NumberFree(LCMb,
"execarg"); NumberFree(LCMc,
"execarg");
385 for ( ii = 0; ii < kGCD; ii++ ) GCDbuffer[ii] = GCDbuffer2[ii];
388 kGCD = 1; GCDbuffer[0] = 1;
393 while ( ( k > 1 ) && ( r3[k-1] == 0 ) ) k--;
394 if ( ( ( LCMbuffer[0] == 1 ) && ( kLCM == 1 ) ) ) {
395 for ( kLCM = 0; kLCM < k; kLCM++ )
396 LCMbuffer[kLCM] = r3[kLCM];
398 else if ( ( k != 1 ) || ( r3[0] != 1 ) ) {
399 if ( GcdLong(BHEAD LCMbuffer,kLCM,(UWORD *)r3,k,LCMb,&kkLCM) ) {
400 NumberFree(GCDbuffer,
"execarg"); NumberFree(GCDbuffer2,
"execarg");
401 NumberFree(LCMbuffer,
"execarg"); NumberFree(LCMb,
"execarg"); NumberFree(LCMc,
"execarg");
404 DivLong((UWORD *)r3,k,LCMb,kkLCM,LCMb,&kkLCM,LCMc,&jLCM);
405 MulLong(LCMbuffer,kLCM,LCMb,kkLCM,LCMc,&jLCM);
406 for ( kLCM = 0; kLCM < jLCM; kLCM++ )
407 LCMbuffer[kLCM] = LCMc[kLCM];
415 r3 = (WORD *)(GCDbuffer);
416 if ( kGCD == kLCM ) {
417 for ( jGCD = 0; jGCD < kGCD; jGCD++ )
418 r3[jGCD+kGCD] = LCMbuffer[jGCD];
421 else if ( kGCD > kLCM ) {
422 for ( jGCD = 0; jGCD < kLCM; jGCD++ )
423 r3[jGCD+kGCD] = LCMbuffer[jGCD];
424 for ( jGCD = kLCM; jGCD < kGCD; jGCD++ )
429 for ( jGCD = kGCD; jGCD < kLCM; jGCD++ )
431 for ( jGCD = 0; jGCD < kLCM; jGCD++ )
432 r3[jGCD+kLCM] = LCMbuffer[jGCD];
436 NumberFree(GCDbuffer2,
"execarg");
437 NumberFree(LCMbuffer,
"execarg");
438 NumberFree(LCMb,
"execarg"); NumberFree(LCMc,
"execarg");
448 if ( scale && ( factor == 0 || *factor > 0 ) )
454 if ( scale && ( factor == 0 || *factor ) ) {
455 size = term[*term-1];
456 size = REDLENG(size);
457 if ( MulRat(BHEAD (UWORD *)rstop,size,(UWORD *)r3,k,
458 (UWORD *)rstop,&size) )
goto execargerr;
459 size = INCLENG(size);
460 k = size < 0 ? -size: size;
461 rstop[k-1] = size*sign;
462 *term = (WORD)(rstop - term) + k;
466 if ( factor && *factor >= 1 ) {
471 r3 = r2 - ABS(r2[-1]);
474 if ( j != *r5 ) { r1 = r2;
continue; }
477 if ( *r5 != *r6 )
break;
480 if ( j > 0 ) { r1 = r2;
continue; }
483 if ( r1 >= r4 )
continue;
488 r3 = r2 - ABS(r2[-1]);
490 if ( *r3 == 1 && r3[1] == 1 ) {
491 if ( r2[-1] == 3 )
continue;
492 if ( r2[-1] == -3 && type == TYPENORM3 )
continue;
499 if ( type == TYPENORM && scale && ( factor == 0 || *factor ) ) {
504 size = term[*term-1];
505 size = REDLENG(size);
507 for ( jj = 0; jj < scale; jj++ ) {
508 if ( MulRat(BHEAD (UWORD *)rstop,size,(UWORD *)r3,k,
509 (UWORD *)rstop,&size) )
goto execargerr;
513 for ( jj = 0; jj > scale; jj-- ) {
514 if ( DivRat(BHEAD (UWORD *)rstop,size,(UWORD *)r3,k,
515 (UWORD *)rstop,&size) )
goto execargerr;
518 size = INCLENG(size);
519 k = size < 0 ? -size: size;
520 rstop[k-1] = size*sign;
521 *term = (WORD)(rstop - term) + k;
528 r4 =
AddRHS(AT.ebufnum,1);
529 while ( (r4+j+12) > CC->Top ) r4 =
DoubleCbuffer(AT.ebufnum,r4,3);
532 for ( k = 0; k < i; k++ ) *r4++ = r3[i+k];
533 for ( k = 0; k < i; k++ ) *r4++ = r3[k];
534 if ( ( type == TYPENORM3 ) || ( type == TYPENORM4 ) ) *r4++ = j*sign;
535 else *r4++ = r3[j-1];
537 CC->rhs[CC->numrhs+1] = r4;
539 AT.mulpat[5] = CC->numrhs;
540 AT.mulpat[7] = AT.ebufnum;
542 else if ( type == TYPEARGTOEXTRASYMBOL ) {
546 WORD tmp[MaX(9,FUNHEAD+5)];
556 tmp[3] = r[1] > 0 ? 3 : -3;
580 tmp[6] = r[0] != -MINVECTOR ? 3 : -3;
584 if ( r[0] <= -FUNCTION ) {
596 MLOCK(ErrorMessageLock);
597 MesPrint(
"Unknown fast notation found (TYPEARGTOEXTRASYMBOL)");
598 MUNLOCK(ErrorMessageLock);
602 n = FindSubexpression(tmp);
610 WORD old_rr0 = r[r[0]];
612 n = FindSubexpression(r+ARGHEAD);
616 if ( AT.WorkPointer+2 > AT.WorkTop ) {
617 MLOCK(ErrorMessageLock);
619 MUNLOCK(ErrorMessageLock);
629 r1[1] = MAXVARIABLES-n;
632 r2 = r + (r[0] > 0 ? r[0] : r[0] <= -FUNCTION ? 1 : 2);
648 while ( --j >= 0 ) *m++ = *r++;
654 if ( type == TYPENORM || type == TYPENORM2 || type == TYPENORM3 || type == TYPENORM4 ) {
655 if ( MultDo(BHEAD r1,AT.mulpat) )
goto execargerr;
656 AT.WorkPointer = r1 + *r1;
658 if (
Generator(BHEAD r1,level) )
goto execargerr;
663 r2 = r + (( *r <= -FUNCTION ) ? 1:2);
667 AT.WorkPointer = r1 + *r1;
673 if ( type == TYPENORM || type == TYPENORM2 || type == TYPENORM3 || type == TYPENORM4 ) {
674 if ( MultDo(BHEAD m,AT.mulpat) )
goto execargerr;
675 AT.WorkPointer = m + *m;
677 if ( (*m != 0 ) &&
Generator(BHEAD m,level) )
goto execargerr;
680 if (
EndSort(BHEAD AT.WorkPointer+ARGHEAD,1) < 0 )
goto execargerr;
681 AR.DeferFlag = olddefer;
685 m = AT.WorkPointer+ARGHEAD;
686 while ( *m ) m += *m;
687 k = WORDDIF(m,AT.WorkPointer);
689 AT.WorkPointer[1] = 0;
690 if ( ToFast(AT.WorkPointer,AT.WorkPointer) ) {
691 if ( *AT.WorkPointer <= -FUNCTION ) k = 1;
695 if ( *r3 > 0 ) j = k - *r3;
696 else if ( *r3 <= -FUNCTION ) j = k - 1;
704 while ( m > AT.WorkPointer ) *--r = *--m;
708 while ( m > r2 ) *--r = *--m;
713 while ( r2 < r1 ) *r++ = *r2++;
720 CC->numrhs = oldnumrhs;
721 CC->Pointer = CC->Buffer + oldcpointer;
730 if ( ( type == TYPESPLITARG || type == TYPESPLITARG2
731 || type == TYPESPLITFIRSTARG || type == TYPESPLITLASTARG ) &&
732 AT.pWorkPointer > oldppointer ) {
734 r1 = AT.WorkPointer + 1;
736 while ( t < rstop ) {
737 if ( lp < AT.pWorkPointer && t == AT.pWorkSpace[lp] ) {
741 r2 = r1;
while ( t < m ) *r1++ = *t++;
745 if ( lp >= AT.pWorkPointer || t != AT.pWorkSpace[lp+1] ) {
746 if ( *t > 0 ) t[1] = 0;
747 while ( t < m ) *r1++ = *t++;
758 if ( type == TYPESPLITFIRSTARG ) {
759 r4 = r1; r5 = t; r7 = oldwork;
760 *r1++ = *t + ARGHEAD;
761 for ( i = 1; i < ARGHEAD; i++ ) *r1++ = 0;
775 if ( ToFast(r4,r4) ) {
777 if ( *r1 > -FUNCTION ) r1++;
783 *r1++ = i+ARGHEAD; *r1++ = 0;
786 if ( ToFast(r4,r4) ) {
788 if ( *r1 > -FUNCTION ) r1++;
795 else if ( type == TYPESPLITLASTARG ) {
796 r4 = r1; r5 = t; r7 = oldwork;
797 *r1++ = *t + ARGHEAD;
798 for ( i = 1; i < ARGHEAD; i++ ) *r1++ = 0;
812 if ( ToFast(r4,r4) ) {
814 if ( *r1 > -FUNCTION ) r1++;
820 *r1++ = i+ARGHEAD; *r1++ = 0;
823 if ( ToFast(r4,r4) ) {
825 if ( *r1 > -FUNCTION ) r1++;
832 else if ( factor == 0 || ( type == TYPESPLITARG2 && *factor == 0 ) ) {
835 *r1++ = *t + ARGHEAD;
836 for ( i = 1; i < ARGHEAD; i++ ) *r1++ = 0;
838 while ( --i >= 0 ) *r1++ = *t++;
839 if ( ToFast(r4,r4) ) {
841 if ( *r1 > -FUNCTION ) r1++;
846 else if ( type == TYPESPLITARG2 ) {
851 WORD *oRepFunList = AN.RepFunList;
852 WORD *oWildMask = AT.WildMask, *oWildValue = AN.WildValue;
853 AN.WildValue = AT.locwildvalue; AT.WildMask = AT.locwildvalue+2;
855 r4 = r1; r5 = t; r7 = oldwork;
856 *r1++ = *t + ARGHEAD;
857 for ( i = 1; i < ARGHEAD; i++ ) *r1++ = 0;
860 AN.UseFindOnly = 0; oldwork2 = AT.WorkPointer;
862 AT.WorkPointer = r1+AN.RepFunNum+2;
864 if ( FindRest(BHEAD t,factor) &&
865 ( AN.UsedOtherFind || FindOnce(BHEAD t,factor) ) ) {
869 else if ( factor[0] == FUNHEAD+1 && factor[1] >= FUNCTION ) {
870 WORD *rr1 = t+1, *rr2 = t+i;
872 while ( rr1 < rr2 ) {
873 if ( *rr1 == factor[1] )
break;
887 AT.WorkPointer = oldwork2;
889 AN.RepFunList = oRepFunList;
892 if ( ToFast(r4,r4) ) {
894 if ( *r1 > -FUNCTION ) r1++;
900 *r1++ = i+ARGHEAD; *r1++ = 0;
903 if ( ToFast(r4,r4) ) {
905 if ( *r1 > -FUNCTION ) r1++;
911 AT.WildMask = oWildMask; AN.WildValue = oWildValue;
918 *r1++ = *t + ARGHEAD;
919 for ( i = 1; i < ARGHEAD; i++ ) *r1++ = 0;
922 r6 = t + *t; r6 -= ABS(r6[-1]);
923 if ( (r6 - t) == *factor ) {
925 for ( ; k > 0; k-- ) {
926 if ( t[k] != factor[k] )
break;
929 j = r3 - t; t += *t;
continue;
932 else if ( (r6 - t) == 1 && *factor == 0 ) {
933 j = r3 - t; t += *t;
continue;
940 if ( ToFast(r4,r4) ) {
942 if ( *r1 > -FUNCTION ) r1++;
947 *r1++ = *t + ARGHEAD;
948 for ( i = 1; i < ARGHEAD; i++ ) *r1++ = 0;
950 while ( --i >= 0 ) *r1++ = *t++;
951 if ( ToFast(r4,r4) ) {
953 if ( *r1 > -FUNCTION ) r1++;
964 while ( t < r ) *r1++ = *t++;
968 while ( t < r ) *r1++ = *t++;
972 while ( --i >= 0 ) *t++ = *m++;
973 if ( AT.WorkPointer < m ) AT.WorkPointer = m;
979 if ( ( type == TYPEFACTARG || type == TYPEFACTARG2 ) &&
980 AT.pWorkPointer > oldppointer ) {
982 r1 = AT.WorkPointer + 1;
984 while ( t < rstop ) {
985 if ( lp < AT.pWorkPointer && AT.pWorkSpace[lp] == t ) {
989 r2 = r1;
while ( t < m ) *r1++ = *t++;
993 if ( lp >= AT.pWorkPointer || AT.pWorkSpace[lp+1] != t ) {
994 if ( *t > 0 ) t[1] = 0;
995 while ( t < m ) *r1++ = *t++;
1004 if ( factor && ( *factor == 0 && *t == -SNUMBER ) ) {
1006 if ( *t == 0 ) *r1++ = *t++;
1007 else { *r1++ = 1; t++; }
1010 else if ( factor && *factor == 4 && factor[2] == 1 ) {
1011 if ( *t == -SNUMBER ) {
1012 if ( factor[3] < 0 || t[1] >= 0 ) {
1013 while ( t < m ) *r1++ = *t++;
1016 *r1++ = -SNUMBER; *r1++ = -1;
1017 *r1++ = *t++; *r1++ = -*t++;
1021 while ( t < m ) *r1++ = *t++;
1022 *r1++ = -SNUMBER; *r1++ = 1;
1026 else if ( *t == -MINVECTOR ) {
1027 *r1++ = -VECTOR; t++; *r1++ = *t++;
1028 *r1++ = -SNUMBER; *r1++ = -1;
1029 *r1++ = -SNUMBER; *r1++ = 1;
1037 t += ARGHEAD; r5 = t;
1039 if ( r5+*r5 == r3 && factor ) {
1040 if ( *factor == 0 ) {
1042 r9 = r1; *r1++ = 0; *r1++ = 1;
1044 *r1++ = (r6-t)+3; t++;
1045 while ( t < r6 ) *r1++ = *t++;
1046 *r1++ = 1; *r1++ = 1; *r1++ = 3;
1048 if ( ToFast(r9,r9) ) {
1049 if ( *r9 <= -FUNCTION ) r1 = r9+1;
1054 if ( factor[0] == 4 && factor[2] == 1 ) {
1056 r7 = r1; *r1++ = (r6-t)+3+ARGHEAD; *r1++ = 0;
1058 *r1++ = (r6-t)+3; t++;
1059 while ( t < r6 ) *r1++ = *t++;
1060 *r1++ = 1; *r1++ = 1; *r1++ = 3;
1061 if ( ToFast(r7,r7) ) {
1062 if ( *r7 <= -FUNCTION ) r1 = r7+1;
1065 if ( r3[-1] < 0 && factor[3] > 0 ) {
1066 *r1++ = -SNUMBER; *r1++ = -1;
1067 if ( r3[-1] == -3 && r3[-2] == 1
1068 && ( r3[-3] & MAXPOSITIVE ) == r3[-3] ) {
1069 *r1++ = -SNUMBER; *r1++ = r3[-3];
1072 *r1++ = (r3-r6)+1+ARGHEAD;
1076 while ( t < r3 ) *r1++ = *t++;
1081 if ( ( r3[-1] == -3 || r3[-1] == 3 )
1083 && ( r3[-3] & MAXPOSITIVE ) == r3[-3] ) {
1084 *r1++ = -SNUMBER; *r1++ = r3[-3];
1085 if ( r3[-1] < 0 ) r1[-1] = - r1[-1];
1088 *r1++ = (r3-r6)+1+ARGHEAD;
1092 while ( t < r3 ) *r1++ = *t++;
1106 if ( AC.OldFactArgFlag == NEWFACTARG ) {
1107 if ( factor == 0 ) {
1108 WORD *oldworkpointer2 = AT.WorkPointer;
1109 AT.WorkPointer = r1 + AM.MaxTer+FUNHEAD;
1110 if ( ArgFactorize(BHEAD t-ARGHEAD,r1) < 0 ) {
1114 AT.WorkPointer = oldworkpointer2;
1116 while ( *r1 ) { NEXTARG(r1) }
1124 t += *t;
if ( t[-1] > 0 ) { pow = 0;
break; }
1133 EAscrat = (UWORD *)(TermMalloc(
"execarg"));
1134 if ( t + *t == r3 )
goto onetermnew;
1138 while ( --i >= 0 ) EAscrat[i] = r6[i];
1143 if ( AccumGCD(BHEAD EAscrat,&ngcd,(UWORD *)r6,i) )
goto execargerr;
1144 if ( ngcd == 3 && EAscrat[0] == 1 && EAscrat[1] == 1 )
break;
1147 if ( ngcd != 3 || EAscrat[0] != 1 || EAscrat[1] != 1 ) {
1148 if ( pow ) ngcd = -ngcd;
1149 t = r5; r9 = r1; *r1++ = t[-ARGHEAD]; *r1++ = 1;
1150 FILLARG(r1); ngcd = REDLENG(ngcd);
1154 while ( r7 < r6) *r1++ = *r7++;
1157 if ( DivRat(BHEAD (UWORD *)r6,i,EAscrat,ngcd,(UWORD *)r1,&nq) )
goto execargerr;
1160 r1 += i; *r1++ = nq; *r8 = r1-r8;
1163 ngcd = INCLENG(ngcd);
1165 if ( factor && *factor == 0 ) {}
1166 else if ( ( factor && factor[0] == 4 && factor[2] == 1
1167 && factor[3] == -3 ) || pow == 0 ) {
1168 r9 = r1; *r1++ = ARGHEAD+2+i; *r1++ = 0;
1169 FILLARG(r1); *r1++ = i+2;
1170 for ( j = 0; j < i; j++ ) *r1++ = EAscrat[j];
1172 if ( ToFast(r9,r9) ) r1 = r9+2;
1174 else if ( factor && factor[0] == 4 && factor[2] == 1
1175 && factor[3] > 0 && pow ) {
1176 if ( ngcd < 0 ) ngcd = -ngcd;
1177 *r1++ = -SNUMBER; *r1++ = -1;
1178 r9 = r1; *r1++ = ARGHEAD+2+i; *r1++ = 0;
1179 FILLARG(r1); *r1++ = i+2;
1180 for ( j = 0; j < i; j++ ) *r1++ = EAscrat[j];
1182 if ( ToFast(r9,r9) ) r1 = r9+2;
1185 if ( ngcd < 0 ) ngcd = -ngcd;
1186 if ( pow ) { *r1++ = -SNUMBER; *r1++ = -1; }
1187 if ( ngcd != 3 || EAscrat[0] != 1 || EAscrat[1] != 1 ) {
1188 r9 = r1; *r1++ = ARGHEAD+2+i; *r1++ = 0;
1189 FILLARG(r1); *r1++ = i+2;
1190 for ( j = 0; j < i; j++ ) *r1++ = EAscrat[j];
1192 if ( ToFast(r9,r9) ) r1 = r9+2;
1201 if ( factor == 0 || *factor > 2 ) {
1203 *r1++ = -SNUMBER; *r1++ = -1;
1206 t += *t; t[-1] = -t[-1];
1209 t = rr; *r1++ = *t++; *r1++ = 1; t++;
1211 while ( t < m ) *r1++ = *t++;
1214 TermFree(EAscrat,
"execarg");
1223 if ( factor == 0 ) {
1228 if ( *t == SYMBOL ) {
1229 r7 = t; r8 = t + t[1]; t += 2;
1235 GETSTOP(mm,mstop); mm++;
1236 while ( mm < mstop ) {
1237 if ( *mm != SYMBOL ) mm += mm[1];
1240 if ( *mm == SYMBOL ) {
1241 mstop = mm + mm[1]; mm += 2;
1242 while ( *mm != *t && mm < mstop ) mm += 2;
1243 if ( mm >= mstop ) pow = 0;
1244 else if ( pow > 0 && mm[1] > 0 ) {
1245 if ( mm[1] < pow ) pow = mm[1];
1247 else if ( pow < 0 && mm[1] < 0 ) {
1248 if ( mm[1] > pow ) pow = mm[1];
1253 if ( pow == 0 )
break;
1256 if ( pow == 0 ) { t += 2;
continue; }
1260 action = 1; i = pow;
1262 while ( --i >= 0 ) {
1269 *r1++ = 8 + ARGHEAD;
1270 for ( j = 1; j < ARGHEAD; j++ ) *r1++ = 0;
1271 *r1++ = 8; *r1++ = SYMBOL;
1272 *r1++ = 4; *r1++ = *t; *r1++ = -1;
1273 *r1++ = 1; *r1++ = 1; *r1++ = 3;
1283 GETSTOP(mm,mstop); mm++;
1284 while ( mm < mstop ) {
1285 if ( *mm != SYMBOL ) mm += mm[1];
1288 mstop = mm + mm[1]; mm += 2;
1289 while ( mm < mstop && *mm != *t ) mm += 2;
1300 else if ( *t == DOTPRODUCT ) {
1301 r7 = t; r8 = t + t[1]; t += 2;
1307 GETSTOP(mm,mstop); mm++;
1308 while ( mm < mstop ) {
1309 if ( *mm != DOTPRODUCT ) mm += mm[1];
1312 if ( *mm == DOTPRODUCT ) {
1313 mstop = mm + mm[1]; mm += 2;
1314 while ( ( *mm != *t || mm[1] != t[1] )
1315 && mm < mstop ) mm += 3;
1316 if ( mm >= mstop ) pow = 0;
1317 else if ( pow > 0 && mm[2] > 0 ) {
1318 if ( mm[2] < pow ) pow = mm[2];
1320 else if ( pow < 0 && mm[2] < 0 ) {
1321 if ( mm[2] > pow ) pow = mm[2];
1326 if ( pow == 0 )
break;
1329 if ( pow == 0 ) { t += 3;
continue; }
1333 action = 1; i = pow;
1335 while ( --i >= 0 ) {
1336 *r1++ = 9 + ARGHEAD;
1337 for ( j = 1; j < ARGHEAD; j++ ) *r1++ = 0;
1338 *r1++ = 9; *r1++ = DOTPRODUCT;
1339 *r1++ = 5; *r1++ = *t; *r1++ = t[1]; *r1++ = 1;
1340 *r1++ = 1; *r1++ = 1; *r1++ = 3;
1345 *r1++ = 9 + ARGHEAD;
1346 for ( j = 1; j < ARGHEAD; j++ ) *r1++ = 0;
1347 *r1++ = 9; *r1++ = DOTPRODUCT;
1348 *r1++ = 5; *r1++ = *t; *r1++ = t[1]; *r1++ = -1;
1349 *r1++ = 1; *r1++ = 1; *r1++ = 3;
1359 GETSTOP(mm,mstop); mm++;
1360 while ( mm < mstop ) {
1361 if ( *mm != DOTPRODUCT ) mm += mm[1];
1364 mstop = mm + mm[1]; mm += 2;
1365 while ( mm < mstop && ( *mm != *t
1366 || mm[1] != t[1] ) ) mm += 3;
1377 else if ( *t == DELTA || *t == VECTOR ) {
1378 r7 = t; r8 = t + t[1]; t += 2;
1384 GETSTOP(mm,mstop); mm++;
1385 while ( mm < mstop ) {
1386 if ( *mm != *r7 ) mm += mm[1];
1390 mstop = mm + mm[1]; mm += 2;
1391 while ( ( *mm != *t || mm[1] != t[1] )
1392 && mm < mstop ) mm += 2;
1393 if ( mm >= mstop ) pow = 0;
1396 if ( pow == 0 )
break;
1399 if ( pow == 0 ) { t += 2;
continue; }
1404 *r1++ = 8 + ARGHEAD;
1405 for ( j = 1; j < ARGHEAD; j++ ) *r1++ = 0;
1406 *r1++ = 8; *r1++ = *r7;
1407 *r1++ = 4; *r1++ = *t; *r1++ = t[1];
1408 *r1++ = 1; *r1++ = 1; *r1++ = 3;
1415 GETSTOP(mm,mstop); mm++;
1416 while ( mm < mstop ) {
1417 if ( *mm != *r7 ) mm += mm[1];
1420 mstop = mm + mm[1]; mm += 2;
1421 while ( mm < mstop && (
1422 *mm != *t || mm[1] != t[1] ) ) mm += 2;
1423 *mm = mm[1] = NOINDEX;
1426 *t = t[1] = NOINDEX;
1434 else if ( *t == INDEX ) {
1435 r7 = t; r8 = t + t[1]; t += 2;
1441 GETSTOP(mm,mstop); mm++;
1442 while ( mm < mstop ) {
1443 if ( *mm != *r7 ) mm += mm[1];
1447 mstop = mm + mm[1]; mm += 2;
1449 && mm < mstop ) mm++;
1450 if ( mm >= mstop ) pow = 0;
1453 if ( pow == 0 )
break;
1456 if ( pow == 0 ) { t++;
continue; }
1473 if ( *t < 0 ) { *r1++ = -VECTOR; }
1474 else { *r1++ = -INDEX; }
1483 GETSTOP(mm,mstop); mm++;
1484 while ( mm < mstop ) {
1485 if ( *mm != *r7 ) mm += mm[1];
1488 mstop = mm + mm[1]; mm += 2;
1489 while ( mm < mstop &&
1490 *mm != *t ) mm += 1;
1501 else if ( *t >= FUNCTION ) {
1506 if ( *t >= FUNCTION &&
1507 functions[*t-FUNCTION].commute == 0 ) ncom = 0;
1511 while ( mm < t && ( *mm == DUMMYFUN
1512 || *mm == DUMMYTEN ) ) mm += mm[1];
1513 if ( mm < t ) { t += t[1];
continue; }
1515 mm = rnext; pow = 1;
1518 GETSTOP(mm,mstop); mm++;
1519 while ( mm < mstop ) {
1520 if ( *mm == *t && mm[1] == t[1] ) {
1521 for ( i = 2; i < t[1]; i++ ) {
1522 if ( mm[i] != t[i] )
break;
1525 { mm += mm[1];
goto nextmterm; }
1527 if ( ncom && *mm != DUMMYFUN && *mm != DUMMYTEN )
1531 if ( mm >= mstop ) pow = 0;
1532 if ( pow == 0 )
break;
1533 nextmterm: mm = mnext;
1535 if ( pow == 0 ) { t += t[1];
continue; }
1540 *r1++ = t[1] + 4 + ARGHEAD;
1541 for ( i = 1; i < ARGHEAD; i++ ) *r1++ = 0;
1543 for ( i = 0; i < t[1]; i++ ) *r1++ = t[i];
1544 *r1++ = 1; *r1++ = 1; *r1++ = 3;
1551 GETSTOP(mm,mstop); mm++;
1552 while ( mm < mstop ) {
1553 if ( *mm == *t && mm[1] == t[1] ) {
1554 for ( i = 2; i < t[1]; i++ ) {
1555 if ( mm[i] != t[i] )
break;
1558 if ( functions[*t-FUNCTION].spec > 0 )
1568 nextterm: mm = mnext;
1570 if ( functions[*t-FUNCTION].spec > 0 )
1588 t += *t;
if ( t[-1] > 0 ) { pow = 0;
break; }
1598 EAscrat = (UWORD *)(TermMalloc(
"execarg"));
1599 if ( t + *t == r3 )
goto oneterm;
1603 while ( --i >= 0 ) EAscrat[i] = r6[i];
1608 if ( AccumGCD(BHEAD EAscrat,&ngcd,(UWORD *)r6,i) )
goto execargerr;
1609 if ( ngcd == 3 && EAscrat[0] == 1 && EAscrat[1] == 1 )
break;
1612 if ( ngcd != 3 || EAscrat[0] != 1 || EAscrat[1] != 1 ) {
1613 if ( pow ) ngcd = -ngcd;
1614 t = r5; r9 = r1; *r1++ = t[-ARGHEAD]; *r1++ = 1;
1615 FILLARG(r1); ngcd = REDLENG(ngcd);
1619 while ( r7 < r6) *r1++ = *r7++;
1622 if ( DivRat(BHEAD (UWORD *)r6,i,EAscrat,ngcd,(UWORD *)r1,&nq) )
goto execargerr;
1625 r1 += i; *r1++ = nq; *r8 = r1-r8;
1628 ngcd = INCLENG(ngcd);
1630 if ( factor && *factor == 0 ) {}
1631 else if ( ( factor && factor[0] == 4 && factor[2] == 1
1632 && factor[3] == -3 ) || pow == 0 ) {
1633 r9 = r1; *r1++ = ARGHEAD+2+i; *r1++ = 0;
1634 FILLARG(r1); *r1++ = i+2;
1635 for ( j = 0; j < i; j++ ) *r1++ = EAscrat[j];
1637 if ( ToFast(r9,r9) ) r1 = r9+2;
1639 else if ( factor && factor[0] == 4 && factor[2] == 1
1640 && factor[3] > 0 && pow ) {
1641 if ( ngcd < 0 ) ngcd = -ngcd;
1642 *r1++ = -SNUMBER; *r1++ = -1;
1643 r9 = r1; *r1++ = ARGHEAD+2+i; *r1++ = 0;
1644 FILLARG(r1); *r1++ = i+2;
1645 for ( j = 0; j < i; j++ ) *r1++ = EAscrat[j];
1647 if ( ToFast(r9,r9) ) r1 = r9+2;
1650 if ( ngcd < 0 ) ngcd = -ngcd;
1651 if ( pow ) { *r1++ = -SNUMBER; *r1++ = -1; }
1652 if ( ngcd != 3 || EAscrat[0] != 1 || EAscrat[1] != 1 ) {
1653 r9 = r1; *r1++ = ARGHEAD+2+i; *r1++ = 0;
1654 FILLARG(r1); *r1++ = i+2;
1655 for ( j = 0; j < i; j++ ) *r1++ = EAscrat[j];
1657 if ( ToFast(r9,r9) ) r1 = r9+2;
1666 if ( factor == 0 || *factor > 2 ) {
1668 *r1++ = -SNUMBER; *r1++ = -1;
1671 t += *t; t[-1] = -t[-1];
1674 t = rr; *r1++ = *t++; *r1++ = 1; t++;
1676 while ( t < m ) *r1++ = *t++;
1679 TermFree(EAscrat,
"execarg");
1689 while ( t < r ) *r1++ = *t++;
1693 while ( t < r ) *r1++ = *t++;
1697 while ( --i >= 0 ) *t++ = *m++;
1698 if ( AT.WorkPointer < t ) AT.WorkPointer = t;
1703 AR.Cnumlhs = oldnumlhs;
1704 if ( action && Normalize(BHEAD term) )
goto execargerr;
1705 AT.WorkPointer = oldwork;
1706 if ( AT.WorkPointer < term + *term ) AT.WorkPointer = term + *term;
1707 AT.pWorkPointer = oldppointer;
1708 if ( GCDbuffer ) NumberFree(GCDbuffer,
"execarg");
1711 AT.WorkPointer = oldwork;
1712 AT.pWorkPointer = oldppointer;
1713 MLOCK(ErrorMessageLock);
1715 MUNLOCK(ErrorMessageLock);
1724 WORD execterm(
PHEAD WORD *term, WORD level)
1727 CBUF *C = cbuf+AM.rbufnum;
1728 WORD oldnumlhs = AR.Cnumlhs;
1729 WORD maxisat = C->lhs[level][2];
1731 WORD *oldworkpointer = AT.WorkPointer;
1733 WORD olddeferflag = AR.DeferFlag, tryterm = 0;
1736 AR.Cnumlhs = C->lhs[level][3];
1743 AN.FunSorts[AR.sLevel]->PolyFlag = ( AR.PolyFun != 0 ) ? AR.PolyFunType: 0;
1744 if ( AR.PolyFun == 0 ) { AN.FunSorts[AR.sLevel]->PolyFlag = 0; }
1745 else if ( AR.PolyFunType == 1 ) { AN.FunSorts[AR.sLevel]->PolyFlag = 1; }
1746 else if ( AR.PolyFunType == 2 ) {
1747 if ( AR.PolyFunExp == 2 ) AN.FunSorts[AR.sLevel]->PolyFlag = 1;
1748 else AN.FunSorts[AR.sLevel]->PolyFlag = 2;
1753 t1 = oldworkpointer;
1754 i = *term;
while ( --i >= 0 ) *t1++ = *term++;
1755 AT.WorkPointer = t1;
1756 if (
Generator(BHEAD oldworkpointer,level) )
goto exectermerr;
1760 if (
Generator(BHEAD term,level) )
goto exectermerr;
1763 if ( tryterm ) { TermFree(buffer1,
"buffer in sort statement"); tryterm = 0; }
1764 else { M_free((
void *)buffer1,
"buffer in sort statement"); }
1768 if (
EndSort(BHEAD (WORD *)((VOID *)(&buffer1)),2) < 0 )
goto exectermerr;
1769 tryterm = AN.tryterm; AN.tryterm = 0;
1771 }
while ( AR.Cnumlhs < maxisat );
1772 AR.Cnumlhs = oldnumlhs;
1773 AR.DeferFlag = olddeferflag;
1776 t1 = oldworkpointer;
1777 i = *term;
while ( --i >= 0 ) *t1++ = *term++;
1778 AT.WorkPointer = t1;
1779 if (
Generator(BHEAD oldworkpointer,level) )
goto exectermerr;
1781 if ( tryterm ) { TermFree(buffer1,
"buffer in term statement"); tryterm = 0; }
1782 else { M_free(buffer1,
"buffer in term statement"); }
1784 AT.WorkPointer = oldworkpointer;
1787 AT.WorkPointer = oldworkpointer;
1788 AR.DeferFlag = olddeferflag;
1789 MLOCK(ErrorMessageLock);
1790 MesCall(
"execterm");
1791 MUNLOCK(ErrorMessageLock);
1800 int ArgumentImplode(
PHEAD WORD *term, WORD *thelist)
1803 WORD *liststart, *liststop, *inlist;
1804 WORD *w, *t, *tend, *tstop, *tt, *ttstop, *ttt, ncount, i;
1806 liststop = thelist + thelist[1];
1807 liststart = thelist + 2;
1810 tstop = tend - ABS(tend[-1]);
1812 while ( t < tstop ) {
1813 if ( *t >= FUNCTION ) {
1815 while ( inlist < liststop && *inlist != *t ) inlist += inlist[1];
1816 if ( inlist < liststop ) {
1817 tt = t; ttstop = t + t[1]; w = AT.WorkPointer;
1818 for ( i = 0; i < FUNHEAD; i++ ) *w++ = *tt++;
1819 while ( tt < ttstop ) {
1821 if ( *tt == -SNUMBER && tt[1] == 0 ) {
1822 ncount = 1; ttt = tt; tt += 2;
1823 while ( tt < ttstop && *tt == -SNUMBER && tt[1] == 0 ) {
1828 if ( tt < ttstop && *tt == -SNUMBER && ( tt[1] == 1 || tt[1] == -1 ) ) {
1830 *w++ = (ncount+1) * tt[1];
1834 else if ( ( tt[0] == tt[ARGHEAD] + ARGHEAD )
1835 && ( ABS(tt[tt[0]-1]) == 3 )
1836 && ( tt[tt[0]-2] == 1 )
1837 && ( tt[tt[0]-3] == 1 ) ) {
1838 i = *tt; NCOPY(w,tt,i)
1842 else if ( *tt == -SYMBOL ) {
1850 *w++ = ncount+1; *w++ = 1; *w++ = 3;
1854 else if ( *tt <= -FUNCTION ) {
1855 *w++ = ARGHEAD+FUNHEAD+4;
1861 *w++ = ncount+1; *w++ = 1; *w++ = 3;
1865 while ( ttt < tt ) *w++ = *ttt++;
1866 if ( tt < ttstop && *tt == -SNUMBER ) {
1867 *w++ = *tt++; *w++ = *tt++;
1871 else if ( *tt <= -FUNCTION ) {
1874 else if ( *tt < 0 ) {
1879 i = *tt; NCOPY(w,tt,i)
1882 AT.WorkPointer[1] = w - AT.WorkPointer;
1883 while ( tt < tend ) *w++ = *tt++;
1884 ttt = AT.WorkPointer; tt = t;
1885 while ( ttt < w ) *tt++ = *ttt++;
1886 term[0] = tt - term;
1887 AT.WorkPointer = tt;
1888 tend = tt; tstop = tt - ABS(tt[-1]);
1894 if ( Normalize(BHEAD term) )
return(-1);
1904 int ArgumentExplode(
PHEAD WORD *term, WORD *thelist)
1907 WORD *liststart, *liststop, *inlist, *old;
1908 WORD *w, *t, *tend, *tstop, *tt, *ttstop, *ttt, ncount, i;
1911 liststop = thelist + thelist[1];
1912 liststart = thelist + 2;
1915 tstop = tend - ABS(tend[-1]);
1917 while ( t < tstop ) {
1918 if ( *t >= FUNCTION ) {
1920 while ( inlist < liststop && *inlist != *t ) inlist += inlist[1];
1921 if ( inlist < liststop ) {
1922 tt = t; ttstop = t + t[1]; w = AT.WorkPointer;
1923 for ( i = 0; i < FUNHEAD; i++ ) *w++ = *tt++;
1924 while ( tt < ttstop ) {
1925 if ( *tt == -SNUMBER && tt[1] != 0 ) {
1926 if ( tt[1] < AM.MaxTer/((WORD)
sizeof(WORD)*4)
1927 && tt[1] > -(AM.MaxTer/((WORD)
sizeof(WORD)*4))
1928 && ( tt[1] > 1 || tt[1] < -1 ) ) {
1929 ncount = ABS(tt[1]);
1930 while ( ncount > 1 ) {
1931 *w++ = -SNUMBER; *w++ = 0; ncount--;
1934 if ( tt[1] < 0 ) *w++ = -1;
1940 *w++ = *tt++; *w++ = *tt++;
1943 else if ( *tt <= -FUNCTION ) {
1946 else if ( *tt < 0 ) {
1950 else if ( tt[0] == tt[ARGHEAD]+ARGHEAD ) {
1951 ttt = tt + tt[0] - 1;
1952 i = (ABS(ttt[0])-1)/2;
1954 TooMany: old = AN.currentTerm;
1955 AN.currentTerm = term;
1956 MesPrint(
"Too many arguments in output of ArgExplode");
1957 MesPrint(
"Term = %t");
1958 AN.currentTerm = old;
1961 if ( ttt[-1] != 1 )
goto NoExplode;
1963 if ( 2*x > (AT.WorkTop-w)-*term )
goto TooMany;
1965 while ( ncount > 0 ) {
1966 *w++ = -SNUMBER; *w++ = 0; ncount--;
1969 i = *tt; NCOPY(w,tt,i)
1974 i = *tt; NCOPY(w,tt,i)
1977 AT.WorkPointer[1] = w - AT.WorkPointer;
1978 while ( tt < tend ) *w++ = *tt++;
1979 ttt = AT.WorkPointer; tt = t;
1980 while ( ttt < w ) *tt++ = *ttt++;
1981 term[0] = tt - term;
1982 AT.WorkPointer = tt;
1983 tend = tt; tstop = tt - ABS(tt[-1]);
1989 if ( Normalize(BHEAD term) )
return(-1);
2015 int ArgFactorize(
PHEAD WORD *argin, WORD *argout)
2020 WORD *argfree, *argextra, *argcopy, *t, *tstop, *a, *a1, *a2;
2024 WORD startebuf = cbuf[AT.ebufnum].numrhs,oldword;
2025 WORD oldsorttype = AR.SortType, numargs;
2026 int error = 0, action = 0, i, ii, number, sign = 1;
2033 AR.SortType = SORTHIGHFIRST;
2034 if ( oldsorttype != AR.SortType ) {
2036 oldword = argin[*argin]; argin[*argin] = 0;
2040 if ( AN.ncmod != 0 ) {
2041 if ( AN.ncmod != 1 || ( (WORD)AN.cmod[0] < 0 ) ) {
2042 MLOCK(ErrorMessageLock);
2043 MesPrint(
"Factorization modulus a number, greater than a WORD not implemented.");
2044 MUNLOCK(ErrorMessageLock);
2048 MLOCK(ErrorMessageLock);
2049 MesCall(
"ArgFactorize");
2050 MUNLOCK(ErrorMessageLock);
2053 if ( !*t) { t = tstop;
continue; }
2058 EndSort(BHEAD argin+ARGHEAD,0);
2059 argin[*argin] = oldword;
2069 if ( a1[0] == -SNUMBER && ( a1[1] == 1 || a1[1] == -1 ) ) {
2070 if ( a1[1] == -1 ) { sign = -sign; a1[1] = 1; }
2072 a = t = a1+2;
while ( *t ) NEXTARG(t);
2074 t = a1; NCOPY(t,a,i);
2083 else if ( a1[0] == FUNHEAD+ARGHEAD+4 && a1[ARGHEAD] == FUNHEAD+4
2084 && a1[*a1-1] == 3 && a1[*a1-2] == 1 && a1[*a1-3] == 1
2085 && a1[ARGHEAD+1] >= FUNCTION ) {
2086 a = t = a1+*a1;
while ( *t ) NEXTARG(t);
2088 *a1 = -a1[ARGHEAD+1]; t = a1+1; NCOPY(t,a,i);
2094 if ( argfree == 0 ) {
2097 else if ( argfree[0] == ( argfree[ARGHEAD]+ARGHEAD ) ) {
2098 Normalize(BHEAD argfree+ARGHEAD);
2099 argfree[0] = argfree[ARGHEAD]+ARGHEAD;
2101 if ( ( argfree[0] == ARGHEAD+4 ) && ( argfree[ARGHEAD+3] == 3 )
2102 && ( argfree[ARGHEAD+1] == 1 ) && ( argfree[ARGHEAD+2] == 1 ) ) {
2112 t = argfree+ARGHEAD;
2119 EndSort(BHEAD argfree+ARGHEAD,0);
2120 t = argfree+ARGHEAD;
2121 while ( *t ) t += *t;
2122 *argfree = t - argfree;
2128 if ( ( number =
FindArg(BHEAD argfree) ) != 0 ) {
2129 if ( number > 0 ) t = cbuf[AT.fbufnum].rhs[number-1];
2130 else t = cbuf[AC.ffbufnum].rhs[-number-1];
2142 if ( *tstop == -SNUMBER && tstop[1] == -1 ) {
2143 sign = -sign; ii += 2;
2147 a = argout;
while ( *a ) NEXTARG(a);
2149 if ( sign == -1 ) { *a++ = -SNUMBER; *a++ = -1; *a = 0; sign = 1; }
2155 while ( ii > 0 ) { *--a1 = *--a2; ii--; }
2158 if ( *t == -SNUMBER && t[1] == -1 ) { t += 2; }
2159 else { COPY1ARG(a,t) }
2169 argcopy = TermMalloc(
"argcopy");
2170 for ( i = 0; i <= *argfree; i++ ) argcopy[i] = argfree[i];
2172 tstop = argfree + *argfree;
2175 t = argfree + ARGHEAD;
2176 while ( t < tstop ) {
2177 sumcommu += DoesCommu(t);
2180 if ( sumcommu > 1 ) {
2181 MesPrint(
"ERROR: Cannot factorize an argument with more than one noncommuting object");
2185 t = argfree + ARGHEAD;
2187 while ( t < tstop ) {
2188 if ( ( t[1] != SYMBOL ) && ( *t != (ABS(t[*t-1])+1) ) ) {
2194 t = argfree + ARGHEAD;
2195 argextra = AT.WorkPointer;
2197 while ( t < tstop ) {
2201 AR.SortType = oldsorttype;
2202 TermFree(argcopy,
"argcopy");
2203 if ( argfree != argin ) TermFree(argfree,
"argfree");
2204 MesCall(
"ArgFactorize");
2209 t += *t; argextra += *argextra;
2211 if (
EndSort(BHEAD argfree+ARGHEAD,0) ) { error = -2;
goto getout; }
2212 t = argfree + ARGHEAD;
2213 while ( *t > 0 ) t += *t;
2214 *argfree = t - argfree;
2222 while ( *a ) NEXTARG(a);
2223 if ( poly_factorize_argument(BHEAD argfree,a) < 0 ) {
2224 MesCall(
"ArgFactorize");
2233 if ( error == 0 && action ) {
2234 a1 = a; NEXTARG(a1);
2236 CBUF *C = cbuf+AC.cbufnum;
2237 CBUF *CC = cbuf+AT.ebufnum;
2238 WORD *oldworkpointer = AT.WorkPointer;
2239 WORD *argcopy2 = TermMalloc(
"argcopy2"), *a1, *a2;
2240 a1 = a; a2 = argcopy2;
2243 if ( *a1 > -FUNCTION ) *a2++ = *a1++;
2244 *a2++ = *a1++; *a2 = 0;
2249 argextra = AT.WorkPointer;
2251 while ( t < tstop ) {
2252 if ( ConvertFromPoly(BHEAD t,argextra,numxsymbol,CC->numrhs-startebuf+numxsymbol
2253 ,startebuf-numxsymbol,1) <= 0 ) {
2254 TermFree(argcopy2,
"argcopy2");
2260 AT.WorkPointer = argextra + *argextra;
2264 if (
Generator(BHEAD argextra,C->numlhs) ) {
2265 TermFree(argcopy2,
"argcopy2");
2271 AT.WorkPointer = oldworkpointer;
2272 if (
EndSort(BHEAD a2+ARGHEAD,0) ) { error = -5;
goto getout; }
2273 t = a2+ARGHEAD;
while ( *t ) t += *t;
2274 *a2 = t - a2; a2[1] = 0; ZEROARG(a2);
2275 ToFast(a2,a2); NEXTARG(a2);
2279 a2 = argcopy2; a1 = a;
2282 TermFree(argcopy2,
"argcopy2");
2286 CC->numrhs = startebuf;
2289 for ( i = 0; i <= *argcopy; i++ ) a[i] = argcopy[i];
2299 if ( error == 0 && AN.ncmod == 0 ) {
2300 if (
InsertArg(BHEAD argcopy,a,0) < 0 ) { error = -1; }
2310 for ( i = 0; i < ii; i++ ) argcopy[i] = argout[i];
2313 if ( *a1 == -SNUMBER && a1[1] < 0 ) {
2314 sign = -sign; a1[1] = -a1[1];
2316 a2 = a1+2;
while ( *a2 ) NEXTARG(a2);
2317 i = a2-a1-2; a2 = a1+2;
2321 while ( *a1 ) NEXTARG(a1);
2325 if ( *a1 > 0 && *a1 == a1[ARGHEAD]+ARGHEAD && a1[*a1-1] < 0 ) {
2326 a1[*a1-1] = -a1[*a1-1]; sign = -sign;
2328 if ( *a1 == ARGHEAD+4 && a1[ARGHEAD+1] == 1 && a1[ARGHEAD+2] == 1 ) {
2329 a2 = a1+ARGHEAD+4;
while ( *a2 ) NEXTARG(a2);
2330 i = a2-a1-ARGHEAD-4; a2 = a1+ARGHEAD+4;
2335 while ( *a1 ) NEXTARG(a1);
2343 for ( i = 0; i < ii; i++ ) *a2++ = argcopy[i];
2345 if ( sign == -1 ) { *a2++ = -SNUMBER; *a2++ = -1; sign = 1; }
2348 TermFree(argcopy,
"argcopy");
2350 if ( argfree != argin ) TermFree(argfree,
"argfree");
2351 if ( oldsorttype != AR.SortType ) {
2352 AR.SortType = oldsorttype;
2357 oldword = a[*a]; a[*a] = 0;
2368 else { NEXTARG(a); }
2372 t = argout; numargs = 0;
2376 if ( *tt == ABS(t[-1])+1+ARGHEAD && sign == -1 ) { t[-1] = -t[-1]; sign = 1; }
2377 else if ( *tt == -SNUMBER && sign == -1 ) { tt[1] = -tt[1]; sign = 1; }
2381 *t++ = -SNUMBER; *t++ = -1; *t = 0; sign = 1; numargs++;
2392 t = argout; numargs = 0;
2393 while ( *t && *t != -SNUMBER && ( *t < 0 || ( ABS(t[*t-1]) != *t-1 ) ) ) {
2398 if ( numargs > 1 ) {
2401 x[0] = argout[-FUNHEAD];
2402 x[1] = argout[-FUNHEAD+1];
2403 x[2] = argout[-FUNHEAD+2];
2404 while ( *t ) { NEXTARG(t); }
2405 argout[-FUNHEAD] = SQRTFUNCTION;
2406 argout[-FUNHEAD+1] = t-argout+FUNHEAD;
2407 argout[-FUNHEAD+2] = 0;
2408 AT.WorkPointer = t+1;
2409 Lijst = AT.WorkPointer;
2410 for ( i = 0; i < numargs; i++ ) Lijst[i] = i;
2411 AT.WorkPointer += numargs;
2412 error = Symmetrize(BHEAD argout-FUNHEAD,Lijst,numargs,1,SYMMETRIC);
2413 AT.WorkPointer = Lijst;
2414 argout[-FUNHEAD] = x[0];
2415 argout[-FUNHEAD+1] = x[1];
2416 argout[-FUNHEAD+2] = x[2];
2421 tstop = argout;
while ( *tstop ) { NEXTARG(tstop); }
2422 t = argout; number = 0;
2425 if ( *tt == -SNUMBER ) {
2426 if ( number == 0 )
break;
2428 while ( tt > argout ) { *--t = *--tt; }
2429 argout[0] = -SNUMBER; argout[1] = x[0];
2432 else if ( *tt == ABS(t[-1])+1+ARGHEAD ) {
2433 if ( number == 0 )
break;
2435 for ( i = 0; i < ii; i++ ) tstop[i] = tt[i];
2436 while ( tt > argout ) { *--t = *--tt; }
2437 for ( i = 0; i < ii; i++ ) argout[i] = tstop[i];
2466 if ( AN.ncmod != 0 )
return(0);
2467 number = FindTree(AT.fbufnum,a);
2468 if ( number >= 0 )
return(number+1);
2469 number = FindTree(AC.ffbufnum,a);
2470 if ( number >= 0 )
return(-number-1);
2492 bufnum = AT.fbufnum;
2496 else if ( par == 1 ) {
2497 bufnum = AC.ffbufnum;
2500 else {
return(-1); }
2502 AddNtoC(bufnum,*argin,argin,1);
2504 a = argout;
while ( *a ) NEXTARG(a);
2508 return(InsTree(bufnum,C->numrhs));
2524 CBUF *C = cbuf + bufnum;
2526 LONG *weights = (LONG *)Malloc1(2*(C->numrhs+1)*
sizeof(LONG),
"CleanupArgCache");
2527 LONG w, whalf, *extraweights;
2528 WORD *a, *to, *from;
2530 for ( i = 1; i <= C->numrhs; i++ ) {
2531 weights[i] = ((LONG)i) * (boomlijst[i].
usage);
2536 extraweights = weights+C->numrhs+1;
2538 whalf = weights[C->numrhs/2+1];
2544 for ( i = 1; i <= C->numrhs; i++ ) {
2545 from = C->
rhs[i]; w = ((LONG)i) * (boomlijst[i].
usage);
2547 if ( i < C->numrhs-1 ) {
2552 j = C->
rhs[i+1] - from;
2557 else if ( to == from ) {
2558 to += *to + 1;
while ( *to ) NEXTARG(to); to++;
2561 a = from; a += *a+1;
while ( *a ) NEXTARG(a); a++;
2566 weights[k++] = boomlijst[i].
usage;
2576 ClearTree(AT.fbufnum);
2577 for ( i = 1; i <= k; i++ ) {
2578 InsTree(AT.fbufnum,i);
2579 boomlijst[i].
usage = weights[i];
2584 M_free(weights,
"CleanupArgCache");
2593 int ArgSymbolMerge(WORD *t1, WORD *t2)
2595 WORD *t1e = t1+t1[1];
2596 WORD *t2e = t2+t2[1];
2600 while ( t1a < t1e && t2a < t2e ) {
2601 if ( *t1a < *t2a ) {
2602 if ( t1a[1] >= 0 ) {
2604 while ( t3 < t1e ) { t3[-2] = *t3; t3[-1] = t3[1]; t3 += 2; }
2609 else if ( *t1a > *t2a ) {
2610 if ( t2a[1] >= 0 ) t2a += 2;
2613 while ( t3 > t1a ) { *t3 = t3[-2]; t3[1] = t3[-1]; t3 -= 2; }
2620 if ( t2a[1] < t1a[1] ) t1a[1] = t2a[1];
2624 while ( t2a < t2e ) {
2631 while ( t1a < t1e ) {
2632 if ( t1a[1] >= 0 ) {
2634 while ( t3 < t1e ) { t3[-2] = *t3; t3[-1] = t3[1]; t3 += 2; }
2648 int ArgDotproductMerge(WORD *t1, WORD *t2)
2650 WORD *t1e = t1+t1[1];
2651 WORD *t2e = t2+t2[1];
2655 while ( t1a < t1e && t2a < t2e ) {
2656 if ( *t1a < *t2a || ( *t1a == *t2a && t1a[1] < t2a[1] ) ) {
2657 if ( t1a[2] >= 0 ) {
2659 while ( t3 < t1e ) { t3[-3] = *t3; t3[-2] = t3[1]; t3[-1] = t3[2]; t3 += 3; }
2664 else if ( *t1a > *t2a || ( *t1a == *t2a && t1a[1] > t2a[1] ) ) {
2665 if ( t2a[2] >= 0 ) t2a += 3;
2668 while ( t3 > t1a ) { *t3 = t3[-3]; t3[1] = t3[-2]; t3[2] = t3[-1]; t3 -= 3; }
2676 if ( t2a[2] < t1a[2] ) t1a[2] = t2a[2];
2680 while ( t2a < t2e ) {
2688 while ( t1a < t1e ) {
2689 if ( t1a[2] >= 0 ) {
2691 while ( t3 < t1e ) { t3[-3] = *t3; t3[-2] = t3[1]; t3[-1] = t3[2]; t3 += 3; }
2719 WORD *t, *rnext, *r1, *r2, *r3, *r5, *r6, *r7, *r8, *r9;
2720 WORD pow, *mm, *mnext, *mstop, *argin2 = argin, *argin3 = argin, *argfree;
2723 r5 = t = argin + ARGHEAD;
2724 r3 = argin + *argin;
2738 if ( *t == DELTA || *t == VECTOR ) {
2739 r7 = t; r8 = t + t[1]; t += 2;
2745 GETSTOP(mm,mstop); mm++;
2746 while ( mm < mstop ) {
2747 if ( *mm != *r7 ) mm += mm[1];
2751 mstop = mm + mm[1]; mm += 2;
2752 while ( ( *mm != *t || mm[1] != t[1] )
2753 && mm < mstop ) mm += 2;
2754 if ( mm >= mstop ) pow = 0;
2757 if ( pow == 0 )
break;
2760 if ( pow == 0 ) { t += 2;
continue; }
2764 *r1++ = 8 + ARGHEAD;
2765 for ( j = 1; j < ARGHEAD; j++ ) *r1++ = 0;
2766 *r1++ = 8; *r1++ = *r7;
2767 *r1++ = 4; *r1++ = *t; *r1++ = t[1];
2768 *r1++ = 1; *r1++ = 1; *r1++ = 3;
2776 GETSTOP(mm,mstop); mm++;
2777 while ( mm < mstop ) {
2778 if ( *mm != *r7 ) mm += mm[1];
2781 mstop = mm + mm[1]; mm += 2;
2782 while ( mm < mstop && (
2783 *mm != *t || mm[1] != t[1] ) ) mm += 2;
2784 *mm = mm[1] = NOINDEX;
2787 *t = t[1] = NOINDEX;
2795 else if ( *t == INDEX ) {
2796 r7 = t; r8 = t + t[1]; t += 2;
2802 GETSTOP(mm,mstop); mm++;
2803 while ( mm < mstop ) {
2804 if ( *mm != *r7 ) mm += mm[1];
2808 mstop = mm + mm[1]; mm += 2;
2810 && mm < mstop ) mm++;
2811 if ( mm >= mstop ) pow = 0;
2814 if ( pow == 0 )
break;
2817 if ( pow == 0 ) { t++;
continue; }
2821 if ( *t < 0 ) { *r1++ = -VECTOR; }
2822 else { *r1++ = -INDEX; }
2832 GETSTOP(mm,mstop); mm++;
2833 while ( mm < mstop ) {
2834 if ( *mm != *r7 ) mm += mm[1];
2837 mstop = mm + mm[1]; mm += 2;
2838 while ( mm < mstop &&
2839 *mm != *t ) mm += 1;
2850 else if ( *t >= FUNCTION ) {
2855 if ( *t >= FUNCTION &&
2856 functions[*t-FUNCTION].commute == 0 ) ncom = 0;
2860 while ( mm < t && ( *mm == DUMMYFUN
2861 || *mm == DUMMYTEN ) ) mm += mm[1];
2862 if ( mm < t ) { t += t[1];
continue; }
2864 mm = rnext; pow = 1;
2867 GETSTOP(mm,mstop); mm++;
2868 while ( mm < mstop ) {
2869 if ( *mm == *t && mm[1] == t[1] ) {
2870 for ( i = 2; i < t[1]; i++ ) {
2871 if ( mm[i] != t[i] )
break;
2874 { mm += mm[1];
goto nextmterm; }
2876 if ( ncom && *mm != DUMMYFUN && *mm != DUMMYTEN )
2880 if ( mm >= mstop ) pow = 0;
2881 if ( pow == 0 )
break;
2882 nextmterm: mm = mnext;
2884 if ( pow == 0 ) { t += t[1];
continue; }
2888 *r1++ = t[1] + 4 + ARGHEAD;
2889 for ( i = 1; i < ARGHEAD; i++ ) *r1++ = 0;
2891 for ( i = 0; i < t[1]; i++ ) *r1++ = t[i];
2892 *r1++ = 1; *r1++ = 1; *r1++ = 3;
2900 GETSTOP(mm,mstop); mm++;
2901 while ( mm < mstop ) {
2902 if ( *mm == *t && mm[1] == t[1] ) {
2903 for ( i = 2; i < t[1]; i++ ) {
2904 if ( mm[i] != t[i] )
break;
2907 if ( functions[*t-FUNCTION].spec > 0 )
2917 nextterm: mm = mnext;
2919 if ( functions[*t-FUNCTION].spec > 0 )
2945 if ( *t == SYMBOL ) {
2953 *r2++ = SYMBOL; *r2++ = 2;
2955 t = rnext; rnext = rnext + *rnext;
2969 ArgSymbolMerge(r7,r8);
2982 if ( r8[1] < 0 ) { act = 1; pow += -r8[1]*(ARGHEAD+8); }
2983 else { pow += 2*r8[1]; }
2990 t = argin + ARGHEAD;
2996 if ( *t != SYMBOL ) { t += t[1];
continue; }
2997 r8 = r7+2; r9 = t + t[1]; t += 2;
2998 while ( ( t < r9 ) && ( r8 < r2 ) ) {
3000 t[1] -= r8[1]; t += 2; r8 += 2;
3014 r8 = r7+pow; i = r7[1];
3015 while ( --i >= 0 ) r8[i] = r7[i];
3019 for ( i = 0; i < r8[1]; i++ ) { *r1++ = -SYMBOL; *r1++ = *r8; }
3024 argin2 = TermMalloc(
"TakeArgContent2");
3029 r5 = argin2; *r5++ = 0; *r5++ = 0; FILLARG(r5);
3035 *r5++ = *t++ + r7[1];
3036 while ( t < r6 ) *r5++ = *t++;
3037 i = r7[1] - 2; r8 = r7+2;
3038 *r5++ = r7[0]; *r5++ = r7[1];
3039 while ( i > 0 ) { *r5++ = *r8++; *r5++ = -*r8++; i -= 2; }
3040 while ( t < rnext ) *r5++ = *t++;
3041 Normalize(BHEAD r9);
3045 *argin2 = r5-argin2;
3056 if (
EndSort(BHEAD t,0) < 0 )
goto Irreg;
3057 while ( *t ) t += *t;
3058 *argin2 = t - argin2;
3064 r8 = r7+pow; i = r7[1];
3065 while ( --i >= 0 ) r8[i] = r7[i];
3070 for ( i = 0; i < r8[1]; i++ ) { *r1++ = -SYMBOL; *r1++ = *r8; }
3073 for ( i = 0; i < -r8[1]; i++ ) {
3074 *r1++ = ARGHEAD+8; *r1++ = 0;
3076 *r1++ = 8; *r1++ = SYMBOL; *r1++ = 4; *r1++ = *r8;
3077 *r1++ = -1; *r1++ = 1; *r1++ = 1; *r1++ = 3;
3099 if ( *t == DOTPRODUCT ) {
3107 *r2++ = DOTPRODUCT; *r2++ = 2;
3109 t = rnext; rnext = rnext + *rnext;
3123 ArgDotproductMerge(r7,r8);
3136 if ( r8[2] < 0 ) { pow += -r8[2]*(ARGHEAD+9); }
3137 else { pow += r8[2]*(ARGHEAD+9); }
3145 argin3 = TermMalloc(
"TakeArgContent3");
3150 r5 = argin3; *r5++ = 0; *r5++ = 0; FILLARG(r5);
3156 *r5++ = *t++ + r7[1];
3157 while ( t < r6 ) *r5++ = *t++;
3158 i = r7[1] - 2; r8 = r7+2;
3159 *r5++ = r7[0]; *r5++ = r7[1];
3160 while ( i > 0 ) { *r5++ = *r8++; *r5++ = *r8++; *r5++ = -*r8++; i -= 3; }
3161 while ( t < rnext ) *r5++ = *t++;
3162 Normalize(BHEAD r9);
3166 *argin3 = r5-argin3;
3177 if (
EndSort(BHEAD t,0) < 0 )
goto Irreg;
3178 while ( *t ) t += *t;
3179 *argin3 = t - argin3;
3185 r8 = r7+pow; i = r7[1];
3186 while ( --i >= 0 ) r8[i] = r7[i];
3190 for ( i = ABS(r8[2]); i > 0; i-- ) {
3191 *r1++ = ARGHEAD+9; *r1++ = 0; FILLARG(r1);
3192 *r1++ = 9; *r1++ = DOTPRODUCT; *r1++ = 5; *r1++ = *r8;
3193 *r1++ = r8[1]; *r1++ = r8[2] < 0 ? -1: 1;
3194 *r1++ = 1; *r1++ = 1; *r1++ = 3;
3210 t = argin3 + ARGHEAD; pow = 1;
3216 t += *t; t[-1] = -t[-1];
3222 argfree = TermMalloc(
"TakeArgContent1");
3223 if ( AN.cmod != 0 ) {
3224 r1 =
MakeMod(BHEAD argin3,r1,argfree);
3237 if ( argin3 != argin2 ) TermFree(argin3,
"TakeArgContent3");
3238 if ( argin2 != argin ) TermFree(argin2,
"TakeArgContent2");
3241 MesPrint(
"Irregularity while sorting argument in TakeArgContent");
3242 if ( argin3 != argin2 ) TermFree(argin3,
"TakeArgContent3");
3243 if ( argin2 != argin ) TermFree(argin2,
"TakeArgContent2");
3264 UWORD *GCDbuffer, *GCDbuffer2, *LCMbuffer, *LCMb, *LCMc;
3265 WORD *r, *r1, *r2, *r3, *r4, *r5, *rnext, i, k, j;
3266 WORD kGCD, kLCM, kGCD2, kkLCM, jLCM, jGCD;
3267 GCDbuffer = NumberMalloc(
"MakeInteger");
3268 GCDbuffer2 = NumberMalloc(
"MakeInteger");
3269 LCMbuffer = NumberMalloc(
"MakeInteger");
3270 LCMb = NumberMalloc(
"MakeInteger");
3271 LCMc = NumberMalloc(
"MakeInteger");
3272 r4 = argin + *argin;
3273 r = argin + ARGHEAD;
3281 if ( k < 0 ) k = -k;
3282 while ( ( k > 1 ) && ( r3[k-1] == 0 ) ) k--;
3283 for ( kGCD = 0; kGCD < k; kGCD++ ) GCDbuffer[kGCD] = r3[kGCD];
3285 if ( k < 0 ) k = -k;
3287 while ( ( k > 1 ) && ( r3[k-1] == 0 ) ) k--;
3288 for ( kLCM = 0; kLCM < k; kLCM++ ) LCMbuffer[kLCM] = r3[kLCM];
3298 if ( k < 0 ) k = -k;
3299 while ( ( k > 1 ) && ( r3[k-1] == 0 ) ) k--;
3300 if ( ( ( GCDbuffer[0] == 1 ) && ( kGCD == 1 ) ) ) {
3305 else if ( ( ( k != 1 ) || ( r3[0] != 1 ) ) ) {
3306 if ( GcdLong(BHEAD GCDbuffer,kGCD,(UWORD *)r3,k,GCDbuffer2,&kGCD2) ) {
3307 NumberFree(GCDbuffer,
"MakeInteger");
3308 NumberFree(GCDbuffer2,
"MakeInteger");
3309 NumberFree(LCMbuffer,
"MakeInteger");
3310 NumberFree(LCMb,
"MakeInteger"); NumberFree(LCMc,
"MakeInteger");
3311 goto MakeIntegerErr;
3314 for ( i = 0; i < kGCD; i++ ) GCDbuffer[i] = GCDbuffer2[i];
3317 kGCD = 1; GCDbuffer[0] = 1;
3320 if ( k < 0 ) k = -k;
3322 while ( ( k > 1 ) && ( r3[k-1] == 0 ) ) k--;
3323 if ( ( ( LCMbuffer[0] == 1 ) && ( kLCM == 1 ) ) ) {
3324 for ( kLCM = 0; kLCM < k; kLCM++ )
3325 LCMbuffer[kLCM] = r3[kLCM];
3327 else if ( ( k != 1 ) || ( r3[0] != 1 ) ) {
3328 if ( GcdLong(BHEAD LCMbuffer,kLCM,(UWORD *)r3,k,LCMb,&kkLCM) ) {
3329 NumberFree(GCDbuffer,
"MakeInteger"); NumberFree(GCDbuffer2,
"MakeInteger");
3330 NumberFree(LCMbuffer,
"MakeInteger"); NumberFree(LCMb,
"MakeInteger"); NumberFree(LCMc,
"MakeInteger");
3331 goto MakeIntegerErr;
3333 DivLong((UWORD *)r3,k,LCMb,kkLCM,LCMb,&kkLCM,LCMc,&jLCM);
3334 MulLong(LCMbuffer,kLCM,LCMb,kkLCM,LCMc,&jLCM);
3335 for ( kLCM = 0; kLCM < jLCM; kLCM++ )
3336 LCMbuffer[kLCM] = LCMc[kLCM];
3344 r3 = (WORD *)(GCDbuffer);
3345 if ( kGCD == kLCM ) {
3346 for ( jGCD = 0; jGCD < kGCD; jGCD++ )
3347 r3[jGCD+kGCD] = LCMbuffer[jGCD];
3350 else if ( kGCD > kLCM ) {
3351 for ( jGCD = 0; jGCD < kLCM; jGCD++ )
3352 r3[jGCD+kGCD] = LCMbuffer[jGCD];
3353 for ( jGCD = kLCM; jGCD < kGCD; jGCD++ )
3358 for ( jGCD = kGCD; jGCD < kLCM; jGCD++ )
3360 for ( jGCD = 0; jGCD < kLCM; jGCD++ )
3361 r3[jGCD+kLCM] = LCMbuffer[jGCD];
3368 if ( ( j == 3 ) && ( r3[1] == 1 ) && ( (WORD)(r3[0]) > 0 ) ) {
3375 *r1++ = j+1+ARGHEAD; *r1++ = 0; FILLARG(r1);
3376 *r1++ = j+1; r2 = r3;
3377 for ( i = 0; i < k; i++ ) { *r1++ = *r2++; *r1++ = *r2++; }
3385 r2 = argfree + 2; FILLARG(r2)
3391 while ( r < r5 ) *r2++ = *r++;
3393 if ( DivRat(BHEAD (UWORD *)r5,j,GCDbuffer,k,(UWORD *)r2,&i) ) {
3394 goto MakeIntegerErr;
3398 if ( rnext[-1] < 0 ) r2[-1] = -i;
3404 argfree[0] = r2-argfree;
3409 NumberFree(LCMc,
"MakeInteger");
3410 NumberFree(LCMb,
"MakeInteger");
3411 NumberFree(LCMbuffer,
"MakeInteger");
3412 NumberFree(GCDbuffer2,
"MakeInteger");
3413 NumberFree(GCDbuffer,
"MakeInteger");
3417 MesCall(
"MakeInteger");
3435 WORD *r, *instop, *r1, *m, x, xx, ix, ip;
3437 r = argin; instop = r + *r; r += ARGHEAD;
3439 if ( r[*r-1] < 0 ) x += AN.cmod[0];
3443 argout[0] = -SNUMBER;
3452 m = argfree + ARGHEAD;
3453 while ( r < instop ) {
3454 xx = r[*r-3];
if ( r[*r-1] < 0 ) xx += AN.cmod[0];
3455 xx = (WORD)((((LONG)xx)*ix) % AN.cmod[0]);
3457 i = *r; NCOPY(m,r,i);
3458 m[-3] = xx; m[-1] = 3;
3463 *argfree = m - argfree;
3465 argfree += 2; FILLARG(argfree);
3480 LONG w, *fill, *from1, *from2;
3482 if ( number >= 4 ) {
3483 n1 = number/2; n2 = number - n1;
3490 for ( i = 0; i < n1; i++ ) extraspace[i] = weights[i];
3491 fill = weights; from1 = extraspace; from2 = weights+n1;
3492 while ( n1 > 0 && n2 > 0 ) {
3493 if ( *from1 <= *from2 ) { *fill++ = *from1++; n1--; }
3494 else { *fill++ = *from2++; n2--; }
3496 while ( n1 > 0 ) { *fill++ = *from1++; n1--; }
3501 else if ( number == 3 ) {
3502 if ( weights[0] > weights[1] ) {
3503 if ( weights[1] > weights[2] ) {
3504 w = weights[0]; weights[0] = weights[2]; weights[2] = w;
3506 else if ( weights[0] > weights[2] ) {
3507 w = weights[0]; weights[0] = weights[1];
3508 weights[1] = weights[2]; weights[2] = w;
3511 w = weights[0]; weights[0] = weights[1]; weights[1] = w;
3514 else if ( weights[0] > weights[2] ) {
3515 w = weights[0]; weights[0] = weights[2];
3516 weights[2] = weights[1]; weights[1] = w;
3518 else if ( weights[1] > weights[2] ) {
3519 w = weights[1]; weights[1] = weights[2]; weights[2] = w;
3522 else if ( number == 2 ) {
3523 if ( weights[0] > weights[1] ) {
3524 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)
#define ZeroFillRange(w, begin, end)
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)