56WORD 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;
68 int ii, didpolyratfun;
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]);
128 while ( t < rstop ) {
129 if ( *t >= FUNCTION && functions[*t-FUNCTION].spec <= 0 ) {
142 if ( count <= 0 ) { t += t[1];
continue; }
146 for ( i = 1; i <= count; i++ ) {
153 if ( *r == i )
goto RightNum;
170 r1 = SetElements + Sets[m[1]].first;
171 r2 = SetElements + Sets[m[1]].last;
173 if ( *r1++ == *t )
goto HaveTodo;
176 else if ( m[1] == *t )
goto HaveTodo;
189 if ( *t == AR.PolyFun ) didpolyratfun = 1;
193 while ( --j > 0 ) { NEXTARG(r) }
194 if ( ( type == TYPESPLITARG ) || ( type == TYPESPLITFIRSTARG )
195 || ( type == TYPESPLITLASTARG ) ) {
196 if ( *t > FUNCTION && *r > 0 ) {
198 AT.pWorkSpace[AT.pWorkPointer++] = t;
199 AT.pWorkSpace[AT.pWorkPointer++] = r;
203 else if ( type == TYPESPLITARG2 ) {
204 if ( *t > FUNCTION && *r > 0 ) {
206 AT.pWorkSpace[AT.pWorkPointer++] = t;
207 AT.pWorkSpace[AT.pWorkPointer++] = r;
211 else if ( type == TYPEFACTARG || type == TYPEFACTARG2 ) {
212 if ( *t > FUNCTION || *t == DENOMINATOR ) {
214 mm = r + ARGHEAD; mstop = r + *r;
215 if ( mm + *mm < mstop ) {
217 AT.pWorkSpace[AT.pWorkPointer++] = t;
218 AT.pWorkSpace[AT.pWorkPointer++] = r;
221 if ( *mm == 1+ABS(mstop[-1]) )
continue;
222 if ( mstop[-3] != 1 || mstop[-2] != 1
223 || mstop[-1] != 3 ) {
225 AT.pWorkSpace[AT.pWorkPointer++] = t;
226 AT.pWorkSpace[AT.pWorkPointer++] = r;
229 GETSTOP(mm,mstop); mm++;
230 if ( mm + mm[1] < mstop ) {
232 AT.pWorkSpace[AT.pWorkPointer++] = t;
233 AT.pWorkSpace[AT.pWorkPointer++] = r;
236 if ( *mm == SYMBOL && ( mm[1] > 4 ||
237 ( mm[3] != 1 && mm[3] != -1 ) ) ) {
239 AT.pWorkSpace[AT.pWorkPointer++] = t;
240 AT.pWorkSpace[AT.pWorkPointer++] = r;
243 else if ( *mm == DOTPRODUCT && ( mm[1] > 5 ||
244 ( mm[4] != 1 && mm[4] != -1 ) ) ) {
246 AT.pWorkSpace[AT.pWorkPointer++] = t;
247 AT.pWorkSpace[AT.pWorkPointer++] = r;
250 else if ( ( *mm == DELTA || *mm == VECTOR )
253 AT.pWorkSpace[AT.pWorkPointer++] = t;
254 AT.pWorkSpace[AT.pWorkPointer++] = r;
258 else if ( factor && *factor == 4 && factor[2] == 1 ) {
260 AT.pWorkSpace[AT.pWorkPointer++] = t;
261 AT.pWorkSpace[AT.pWorkPointer++] = r;
264 else if ( factor && *factor == 0
265 && ( *r == -SNUMBER && r[1] != 1 ) ) {
267 AT.pWorkSpace[AT.pWorkPointer++] = t;
268 AT.pWorkSpace[AT.pWorkPointer++] = r;
271 else if ( *r == -MINVECTOR ) {
273 AT.pWorkSpace[AT.pWorkPointer++] = t;
274 AT.pWorkSpace[AT.pWorkPointer++] = r;
280 else if ( type == TYPENORM || type == TYPENORM2 || type == TYPENORM3 || type == TYPENORM4 ) {
283 if ( *r == -MINVECTOR ) { rone = -1; *r = -INDEX; }
284 else if ( *r != -SNUMBER || r[1] == 1 || r[1] == 0 )
continue;
285 else { rone = r[1]; r[1] = 1; }
289 if ( scale && ( factor == 0 || *factor ) ) {
293 if ( type == TYPENORM3 ) k = 1;
300 size = REDLENG(size);
302 for ( jj = 0; jj < scale; jj++ ) {
303 if ( Mully(BHEAD (UWORD *)rstop,&size,(UWORD *)(&rone),k) )
308 for ( jj = 0; jj > scale; jj-- ) {
309 if ( Divvy(BHEAD (UWORD *)rstop,&size,(UWORD *)(&rone),k) )
313 size = INCLENG(size);
314 k = size < 0 ? -size: size;
316 *term = (WORD)(rstop - term) + k;
334 if ( type == TYPENORM4 ) {
340 GCDbuffer = NumberMalloc(
"execarg");
341 GCDbuffer2 = NumberMalloc(
"execarg");
342 LCMbuffer = NumberMalloc(
"execarg");
343 LCMb = NumberMalloc(
"execarg"); LCMc = NumberMalloc(
"execarg");
351 if ( j < 0 ) sign = -1;
355 while ( ( k > 1 ) && ( r3[k-1] == 0 ) ) k--;
356 for ( kGCD = 0; kGCD < k; kGCD++ ) GCDbuffer[kGCD] = r3[kGCD];
360 while ( ( k > 1 ) && ( r3[k-1] == 0 ) ) k--;
361 for ( kLCM = 0; kLCM < k; kLCM++ ) LCMbuffer[kLCM] = r3[kLCM];
372 while ( ( k > 1 ) && ( r3[k-1] == 0 ) ) k--;
373 if ( ( ( GCDbuffer[0] == 1 ) && ( kGCD == 1 ) ) ) {
378 else if ( ( ( k != 1 ) || ( r3[0] != 1 ) ) ) {
379 if ( GcdLong(BHEAD GCDbuffer,kGCD,(UWORD *)r3,k,GCDbuffer2,&kGCD2) ) {
380 NumberFree(GCDbuffer,
"execarg");
381 NumberFree(GCDbuffer2,
"execarg");
382 NumberFree(LCMbuffer,
"execarg");
383 NumberFree(LCMb,
"execarg"); NumberFree(LCMc,
"execarg");
387 for ( ii = 0; ii < kGCD; ii++ ) GCDbuffer[ii] = GCDbuffer2[ii];
390 kGCD = 1; GCDbuffer[0] = 1;
395 while ( ( k > 1 ) && ( r3[k-1] == 0 ) ) k--;
396 if ( ( ( LCMbuffer[0] == 1 ) && ( kLCM == 1 ) ) ) {
397 for ( kLCM = 0; kLCM < k; kLCM++ )
398 LCMbuffer[kLCM] = r3[kLCM];
400 else if ( ( k != 1 ) || ( r3[0] != 1 ) ) {
401 if ( GcdLong(BHEAD LCMbuffer,kLCM,(UWORD *)r3,k,LCMb,&kkLCM) ) {
402 NumberFree(GCDbuffer,
"execarg"); NumberFree(GCDbuffer2,
"execarg");
403 NumberFree(LCMbuffer,
"execarg"); NumberFree(LCMb,
"execarg"); NumberFree(LCMc,
"execarg");
406 DivLong((UWORD *)r3,k,LCMb,kkLCM,LCMb,&kkLCM,LCMc,&jLCM);
407 MulLong(LCMbuffer,kLCM,LCMb,kkLCM,LCMc,&jLCM);
408 for ( kLCM = 0; kLCM < jLCM; kLCM++ )
409 LCMbuffer[kLCM] = LCMc[kLCM];
417 r3 = (WORD *)(GCDbuffer);
418 if ( kGCD == kLCM ) {
419 for ( jGCD = 0; jGCD < kGCD; jGCD++ )
420 r3[jGCD+kGCD] = LCMbuffer[jGCD];
423 else if ( kGCD > kLCM ) {
424 for ( jGCD = 0; jGCD < kLCM; jGCD++ )
425 r3[jGCD+kGCD] = LCMbuffer[jGCD];
426 for ( jGCD = kLCM; jGCD < kGCD; jGCD++ )
431 for ( jGCD = kGCD; jGCD < kLCM; jGCD++ )
433 for ( jGCD = 0; jGCD < kLCM; jGCD++ )
434 r3[jGCD+kLCM] = LCMbuffer[jGCD];
438 NumberFree(GCDbuffer2,
"execarg");
439 NumberFree(LCMbuffer,
"execarg");
440 NumberFree(LCMb,
"execarg"); NumberFree(LCMc,
"execarg");
450 if ( scale && ( factor == 0 || *factor > 0 ) )
456 if ( scale && ( factor == 0 || *factor ) ) {
457 size = term[*term-1];
458 size = REDLENG(size);
459 if ( MulRat(BHEAD (UWORD *)rstop,size,(UWORD *)r3,k,
460 (UWORD *)rstop,&size) )
goto execargerr;
461 size = INCLENG(size);
462 k = size < 0 ? -size: size;
463 rstop[k-1] = size*sign;
464 *term = (WORD)(rstop - term) + k;
468 if ( factor && *factor >= 1 ) {
473 r3 = r2 - ABS(r2[-1]);
476 if ( j != *r5 ) { r1 = r2;
continue; }
479 if ( *r5 != *r6 )
break;
482 if ( j > 0 ) { r1 = r2;
continue; }
485 if ( r1 >= r4 )
continue;
490 r3 = r2 - ABS(r2[-1]);
492 if ( *r3 == 1 && r3[1] == 1 ) {
493 if ( r2[-1] == 3 )
continue;
494 if ( r2[-1] == -3 && type == TYPENORM3 )
continue;
501 if ( type == TYPENORM && scale && ( factor == 0 || *factor ) ) {
506 size = term[*term-1];
507 size = REDLENG(size);
509 for ( jj = 0; jj < scale; jj++ ) {
510 if ( MulRat(BHEAD (UWORD *)rstop,size,(UWORD *)r3,k,
511 (UWORD *)rstop,&size) )
goto execargerr;
515 for ( jj = 0; jj > scale; jj-- ) {
516 if ( DivRat(BHEAD (UWORD *)rstop,size,(UWORD *)r3,k,
517 (UWORD *)rstop,&size) )
goto execargerr;
520 size = INCLENG(size);
521 k = size < 0 ? -size: size;
522 rstop[k-1] = size*sign;
523 *term = (WORD)(rstop - term) + k;
530 r4 =
AddRHS(AT.ebufnum,1);
531 while ( (r4+j+12) > CC->Top ) r4 =
DoubleCbuffer(AT.ebufnum,r4,3);
534 for ( k = 0; k < i; k++ ) *r4++ = r3[i+k];
535 for ( k = 0; k < i; k++ ) *r4++ = r3[k];
536 if ( ( type == TYPENORM3 ) || ( type == TYPENORM4 ) ) *r4++ = j*sign;
537 else *r4++ = r3[j-1];
539 CC->rhs[CC->numrhs+1] = r4;
541 AT.mulpat[5] = CC->numrhs;
542 AT.mulpat[7] = AT.ebufnum;
544 else if ( type == TYPEARGTOEXTRASYMBOL ) {
548 WORD tmp[MaX(9,FUNHEAD+5)];
558 tmp[3] = r[1] > 0 ? 3 : -3;
582 tmp[6] = r[0] != -MINVECTOR ? 3 : -3;
586 if ( r[0] <= -FUNCTION ) {
598 MLOCK(ErrorMessageLock);
599 MesPrint(
"Unknown fast notation found (TYPEARGTOEXTRASYMBOL)");
600 MUNLOCK(ErrorMessageLock);
604 n = FindSubexpression(tmp);
612 WORD old_rr0 = r[r[0]];
614 n = FindSubexpression(r+ARGHEAD);
618 if ( AT.WorkPointer+2 > AT.WorkTop ) {
619 MLOCK(ErrorMessageLock);
621 MUNLOCK(ErrorMessageLock);
631 r1[1] = MAXVARIABLES-n;
634 r2 = r + (r[0] > 0 ? r[0] : r[0] <= -FUNCTION ? 1 : 2);
650 while ( --j >= 0 ) *m++ = *r++;
656 if ( type == TYPENORM || type == TYPENORM2 || type == TYPENORM3 || type == TYPENORM4 ) {
657 if ( MultDo(BHEAD r1,AT.mulpat) )
goto execargerr;
658 AT.WorkPointer = r1 + *r1;
660 if (
Generator(BHEAD r1,level) )
goto execargerr;
665 r2 = r + (( *r <= -FUNCTION ) ? 1:2);
669 AT.WorkPointer = r1 + *r1;
675 if ( type == TYPENORM || type == TYPENORM2 || type == TYPENORM3 || type == TYPENORM4 ) {
676 if ( MultDo(BHEAD m,AT.mulpat) )
goto execargerr;
677 AT.WorkPointer = m + *m;
679 if ( (*m != 0 ) &&
Generator(BHEAD m,level) )
goto execargerr;
682 if (
EndSort(BHEAD AT.WorkPointer+ARGHEAD,1) < 0 )
goto execargerr;
683 AR.DeferFlag = olddefer;
687 m = AT.WorkPointer+ARGHEAD;
688 while ( *m ) m += *m;
689 k = WORDDIF(m,AT.WorkPointer);
691 AT.WorkPointer[1] = 0;
692 if ( ToFast(AT.WorkPointer,AT.WorkPointer) ) {
693 if ( *AT.WorkPointer <= -FUNCTION ) k = 1;
697 if ( *r3 > 0 ) j = k - *r3;
698 else if ( *r3 <= -FUNCTION ) j = k - 1;
706 while ( m > AT.WorkPointer ) *--r = *--m;
710 while ( m > r2 ) *--r = *--m;
715 while ( r2 < r1 ) *r++ = *r2++;
722 CC->numrhs = oldnumrhs;
723 CC->Pointer = CC->Buffer + oldcpointer;
728 if ( didpolyratfun ) {
729 PolyFunDirty(BHEAD term);
736 if ( ( type == TYPESPLITARG || type == TYPESPLITARG2
737 || type == TYPESPLITFIRSTARG || type == TYPESPLITLASTARG ) &&
738 AT.pWorkPointer > oldppointer ) {
740 r1 = AT.WorkPointer + 1;
742 while ( t < rstop ) {
743 if ( lp < AT.pWorkPointer && t == AT.pWorkSpace[lp] ) {
747 r2 = r1;
while ( t < m ) *r1++ = *t++;
751 if ( lp >= AT.pWorkPointer || t != AT.pWorkSpace[lp+1] ) {
752 if ( *t > 0 ) t[1] = 0;
753 while ( t < m ) *r1++ = *t++;
764 if ( type == TYPESPLITFIRSTARG ) {
765 r4 = r1; r5 = t; r7 = oldwork;
766 *r1++ = *t + ARGHEAD;
767 for ( i = 1; i < ARGHEAD; i++ ) *r1++ = 0;
781 if ( ToFast(r4,r4) ) {
783 if ( *r1 > -FUNCTION ) r1++;
789 *r1++ = i+ARGHEAD; *r1++ = 0;
792 if ( ToFast(r4,r4) ) {
794 if ( *r1 > -FUNCTION ) r1++;
801 else if ( type == TYPESPLITLASTARG ) {
802 r4 = r1; r5 = t; r7 = oldwork;
803 *r1++ = *t + ARGHEAD;
804 for ( i = 1; i < ARGHEAD; i++ ) *r1++ = 0;
818 if ( ToFast(r4,r4) ) {
820 if ( *r1 > -FUNCTION ) r1++;
826 *r1++ = i+ARGHEAD; *r1++ = 0;
829 if ( ToFast(r4,r4) ) {
831 if ( *r1 > -FUNCTION ) r1++;
838 else if ( factor == 0 || ( type == TYPESPLITARG2 && *factor == 0 ) ) {
841 *r1++ = *t + ARGHEAD;
842 for ( i = 1; i < ARGHEAD; i++ ) *r1++ = 0;
844 while ( --i >= 0 ) *r1++ = *t++;
845 if ( ToFast(r4,r4) ) {
847 if ( *r1 > -FUNCTION ) r1++;
852 else if ( type == TYPESPLITARG2 ) {
857 WORD *oRepFunList = AN.RepFunList;
858 WORD *oWildMask = AT.WildMask, *oWildValue = AN.WildValue;
859 AN.WildValue = AT.locwildvalue; AT.WildMask = AT.locwildvalue+2;
861 r4 = r1; r5 = t; r7 = oldwork;
862 *r1++ = *t + ARGHEAD;
863 for ( i = 1; i < ARGHEAD; i++ ) *r1++ = 0;
866 AN.UseFindOnly = 0; oldwork2 = AT.WorkPointer;
868 AT.WorkPointer = r1+AN.RepFunNum+2;
870 if ( FindRest(BHEAD t,factor) &&
871 ( AN.UsedOtherFind || FindOnce(BHEAD t,factor) ) ) {
875 else if ( factor[0] == FUNHEAD+1 && factor[1] >= FUNCTION ) {
876 WORD *rr1 = t+1, *rr2 = t+i;
878 while ( rr1 < rr2 ) {
879 if ( *rr1 == factor[1] )
break;
893 AT.WorkPointer = oldwork2;
895 AN.RepFunList = oRepFunList;
898 if ( ToFast(r4,r4) ) {
900 if ( *r1 > -FUNCTION ) r1++;
906 *r1++ = i+ARGHEAD; *r1++ = 0;
909 if ( ToFast(r4,r4) ) {
911 if ( *r1 > -FUNCTION ) r1++;
917 AT.WildMask = oWildMask; AN.WildValue = oWildValue;
924 *r1++ = *t + ARGHEAD;
925 for ( i = 1; i < ARGHEAD; i++ ) *r1++ = 0;
928 r6 = t + *t; r6 -= ABS(r6[-1]);
929 if ( (r6 - t) == *factor ) {
931 for ( ; k > 0; k-- ) {
932 if ( t[k] != factor[k] )
break;
935 j = r3 - t; t += *t;
continue;
938 else if ( (r6 - t) == 1 && *factor == 0 ) {
939 j = r3 - t; t += *t;
continue;
946 if ( ToFast(r4,r4) ) {
948 if ( *r1 > -FUNCTION ) r1++;
953 *r1++ = *t + ARGHEAD;
954 for ( i = 1; i < ARGHEAD; i++ ) *r1++ = 0;
956 while ( --i >= 0 ) *r1++ = *t++;
957 if ( ToFast(r4,r4) ) {
959 if ( *r1 > -FUNCTION ) r1++;
970 while ( t < r ) *r1++ = *t++;
974 while ( t < r ) *r1++ = *t++;
978 while ( --i >= 0 ) *t++ = *m++;
979 if ( AT.WorkPointer < m ) AT.WorkPointer = m;
985 if ( ( type == TYPEFACTARG || type == TYPEFACTARG2 ) &&
986 AT.pWorkPointer > oldppointer ) {
988 r1 = AT.WorkPointer + 1;
990 while ( t < rstop ) {
991 if ( lp < AT.pWorkPointer && AT.pWorkSpace[lp] == t ) {
995 r2 = r1;
while ( t < m ) *r1++ = *t++;
999 if ( lp >= AT.pWorkPointer || AT.pWorkSpace[lp+1] != t ) {
1000 if ( *t > 0 ) t[1] = 0;
1001 while ( t < m ) *r1++ = *t++;
1010 if ( factor && ( *factor == 0 && *t == -SNUMBER ) ) {
1012 if ( *t == 0 ) *r1++ = *t++;
1013 else { *r1++ = 1; t++; }
1016 else if ( factor && *factor == 4 && factor[2] == 1 ) {
1017 if ( *t == -SNUMBER ) {
1018 if ( factor[3] < 0 || t[1] >= 0 ) {
1019 while ( t < m ) *r1++ = *t++;
1022 *r1++ = -SNUMBER; *r1++ = -1;
1023 *r1++ = *t++; *r1++ = -*t++;
1027 while ( t < m ) *r1++ = *t++;
1028 *r1++ = -SNUMBER; *r1++ = 1;
1032 else if ( *t == -MINVECTOR ) {
1033 *r1++ = -VECTOR; t++; *r1++ = *t++;
1034 *r1++ = -SNUMBER; *r1++ = -1;
1035 *r1++ = -SNUMBER; *r1++ = 1;
1043 t += ARGHEAD; r5 = t;
1045 if ( r5+*r5 == r3 && factor ) {
1046 if ( *factor == 0 ) {
1048 r9 = r1; *r1++ = 0; *r1++ = 1;
1050 *r1++ = (r6-t)+3; t++;
1051 while ( t < r6 ) *r1++ = *t++;
1052 *r1++ = 1; *r1++ = 1; *r1++ = 3;
1054 if ( ToFast(r9,r9) ) {
1055 if ( *r9 <= -FUNCTION ) r1 = r9+1;
1060 if ( factor[0] == 4 && factor[2] == 1 ) {
1062 r7 = r1; *r1++ = (r6-t)+3+ARGHEAD; *r1++ = 0;
1064 *r1++ = (r6-t)+3; t++;
1065 while ( t < r6 ) *r1++ = *t++;
1066 *r1++ = 1; *r1++ = 1; *r1++ = 3;
1067 if ( ToFast(r7,r7) ) {
1068 if ( *r7 <= -FUNCTION ) r1 = r7+1;
1071 if ( r3[-1] < 0 && factor[3] > 0 ) {
1072 *r1++ = -SNUMBER; *r1++ = -1;
1073 if ( r3[-1] == -3 && r3[-2] == 1
1074 && ( r3[-3] & MAXPOSITIVE ) == r3[-3] ) {
1075 *r1++ = -SNUMBER; *r1++ = r3[-3];
1078 *r1++ = (r3-r6)+1+ARGHEAD;
1082 while ( t < r3 ) *r1++ = *t++;
1087 if ( ( r3[-1] == -3 || r3[-1] == 3 )
1089 && ( r3[-3] & MAXPOSITIVE ) == r3[-3] ) {
1090 *r1++ = -SNUMBER; *r1++ = r3[-3];
1091 if ( r3[-1] < 0 ) r1[-1] = - r1[-1];
1094 *r1++ = (r3-r6)+1+ARGHEAD;
1098 while ( t < r3 ) *r1++ = *t++;
1112 if ( AC.OldFactArgFlag == NEWFACTARG ) {
1113 if ( factor == 0 ) {
1114 WORD *oldworkpointer2 = AT.WorkPointer;
1115 AT.WorkPointer = r1 + AM.MaxTer+FUNHEAD;
1116 if ( ArgFactorize(BHEAD t-ARGHEAD,r1) < 0 ) {
1120 AT.WorkPointer = oldworkpointer2;
1122 while ( *r1 ) { NEXTARG(r1) }
1130 t += *t;
if ( t[-1] > 0 ) { pow = 0;
break; }
1139 EAscrat = (UWORD *)(TermMalloc(
"execarg"));
1140 if ( t + *t == r3 ) {
1141 if ( factor == 0 || *factor > 2 ) {
1143 *r1++ = -SNUMBER; *r1++ = -1;
1146 t += *t; t[-1] = -t[-1];
1149 t = rr; *r1++ = *t++; *r1++ = 1; t++;
1151 while ( t < m ) *r1++ = *t++;
1158 while ( --i >= 0 ) EAscrat[i] = r6[i];
1163 if ( AccumGCD(BHEAD EAscrat,&ngcd,(UWORD *)r6,i) )
goto execargerr;
1164 if ( ngcd == 3 && EAscrat[0] == 1 && EAscrat[1] == 1 )
break;
1171 if ( pow ) ngcd = -ngcd;
1172 t = r5; r9 = r1; *r1++ = t[-ARGHEAD]; *r1++ = 1;
1173 FILLARG(r1); ngcd = REDLENG(ngcd);
1177 while ( r7 < r6) *r1++ = *r7++;
1180 if ( DivRat(BHEAD (UWORD *)r6,i,EAscrat,ngcd,(UWORD *)r1,&nq) )
goto execargerr;
1183 r1 += i; *r1++ = nq; *r8 = r1-r8;
1186 ngcd = INCLENG(ngcd);
1188 if ( factor && *factor == 0 ) {}
1189 else if ( ( factor && factor[0] == 4 && factor[2] == 1
1190 && factor[3] == -3 ) || pow == 0 ) {
1191 r9 = r1; *r1++ = ARGHEAD+2+i; *r1++ = 0;
1192 FILLARG(r1); *r1++ = i+2;
1193 for ( j = 0; j < i; j++ ) *r1++ = EAscrat[j];
1195 if ( ToFast(r9,r9) ) r1 = r9+2;
1197 else if ( factor && factor[0] == 4 && factor[2] == 1
1198 && factor[3] > 0 && pow ) {
1199 if ( ngcd < 0 ) ngcd = -ngcd;
1200 *r1++ = -SNUMBER; *r1++ = -1;
1201 r9 = r1; *r1++ = ARGHEAD+2+i; *r1++ = 0;
1202 FILLARG(r1); *r1++ = i+2;
1203 for ( j = 0; j < i; j++ ) *r1++ = EAscrat[j];
1205 if ( ToFast(r9,r9) ) r1 = r9+2;
1208 if ( ngcd < 0 ) ngcd = -ngcd;
1209 if ( pow ) { *r1++ = -SNUMBER; *r1++ = -1; }
1210 if ( ngcd != 3 || EAscrat[0] != 1 || EAscrat[1] != 1 ) {
1211 r9 = r1; *r1++ = ARGHEAD+2+i; *r1++ = 0;
1212 FILLARG(r1); *r1++ = i+2;
1213 for ( j = 0; j < i; j++ ) *r1++ = EAscrat[j];
1215 if ( ToFast(r9,r9) ) r1 = r9+2;
1223 TermFree(EAscrat,
"execarg");
1232 if ( factor == 0 ) {
1237 if ( *t == SYMBOL ) {
1238 r7 = t; r8 = t + t[1]; t += 2;
1244 GETSTOP(mm,mstop); mm++;
1245 while ( mm < mstop ) {
1246 if ( *mm != SYMBOL ) mm += mm[1];
1249 if ( *mm == SYMBOL ) {
1250 mstop = mm + mm[1]; mm += 2;
1251 while ( *mm != *t && mm < mstop ) mm += 2;
1252 if ( mm >= mstop ) pow = 0;
1253 else if ( pow > 0 && mm[1] > 0 ) {
1254 if ( mm[1] < pow ) pow = mm[1];
1256 else if ( pow < 0 && mm[1] < 0 ) {
1257 if ( mm[1] > pow ) pow = mm[1];
1262 if ( pow == 0 )
break;
1265 if ( pow == 0 ) { t += 2;
continue; }
1269 action = 1; i = pow;
1271 while ( --i >= 0 ) {
1278 *r1++ = 8 + ARGHEAD;
1279 for ( j = 1; j < ARGHEAD; j++ ) *r1++ = 0;
1280 *r1++ = 8; *r1++ = SYMBOL;
1281 *r1++ = 4; *r1++ = *t; *r1++ = -1;
1282 *r1++ = 1; *r1++ = 1; *r1++ = 3;
1292 GETSTOP(mm,mstop); mm++;
1293 while ( mm < mstop ) {
1294 if ( *mm != SYMBOL ) mm += mm[1];
1297 mstop = mm + mm[1]; mm += 2;
1298 while ( mm < mstop && *mm != *t ) mm += 2;
1309 else if ( *t == DOTPRODUCT ) {
1310 r7 = t; r8 = t + t[1]; t += 2;
1316 GETSTOP(mm,mstop); mm++;
1317 while ( mm < mstop ) {
1318 if ( *mm != DOTPRODUCT ) mm += mm[1];
1321 if ( *mm == DOTPRODUCT ) {
1322 mstop = mm + mm[1]; mm += 2;
1323 while ( ( *mm != *t || mm[1] != t[1] )
1324 && mm < mstop ) mm += 3;
1325 if ( mm >= mstop ) pow = 0;
1326 else if ( pow > 0 && mm[2] > 0 ) {
1327 if ( mm[2] < pow ) pow = mm[2];
1329 else if ( pow < 0 && mm[2] < 0 ) {
1330 if ( mm[2] > pow ) pow = mm[2];
1335 if ( pow == 0 )
break;
1338 if ( pow == 0 ) { t += 3;
continue; }
1342 action = 1; i = pow;
1344 while ( --i >= 0 ) {
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;
1354 *r1++ = 9 + ARGHEAD;
1355 for ( j = 1; j < ARGHEAD; j++ ) *r1++ = 0;
1356 *r1++ = 9; *r1++ = DOTPRODUCT;
1357 *r1++ = 5; *r1++ = *t; *r1++ = t[1]; *r1++ = -1;
1358 *r1++ = 1; *r1++ = 1; *r1++ = 3;
1368 GETSTOP(mm,mstop); mm++;
1369 while ( mm < mstop ) {
1370 if ( *mm != DOTPRODUCT ) mm += mm[1];
1373 mstop = mm + mm[1]; mm += 2;
1374 while ( mm < mstop && ( *mm != *t
1375 || mm[1] != t[1] ) ) mm += 3;
1386 else if ( *t == DELTA || *t == VECTOR ) {
1387 r7 = t; r8 = t + t[1]; t += 2;
1393 GETSTOP(mm,mstop); mm++;
1394 while ( mm < mstop ) {
1395 if ( *mm != *r7 ) mm += mm[1];
1399 mstop = mm + mm[1]; mm += 2;
1400 while ( ( *mm != *t || mm[1] != t[1] )
1401 && mm < mstop ) mm += 2;
1402 if ( mm >= mstop ) pow = 0;
1405 if ( pow == 0 )
break;
1408 if ( pow == 0 ) { t += 2;
continue; }
1413 *r1++ = 8 + ARGHEAD;
1414 for ( j = 1; j < ARGHEAD; j++ ) *r1++ = 0;
1415 *r1++ = 8; *r1++ = *r7;
1416 *r1++ = 4; *r1++ = *t; *r1++ = t[1];
1417 *r1++ = 1; *r1++ = 1; *r1++ = 3;
1424 GETSTOP(mm,mstop); mm++;
1425 while ( mm < mstop ) {
1426 if ( *mm != *r7 ) mm += mm[1];
1429 mstop = mm + mm[1]; mm += 2;
1430 while ( mm < mstop && (
1431 *mm != *t || mm[1] != t[1] ) ) mm += 2;
1432 *mm = mm[1] = NOINDEX;
1435 *t = t[1] = NOINDEX;
1443 else if ( *t == INDEX ) {
1444 r7 = t; r8 = t + t[1]; t += 2;
1450 GETSTOP(mm,mstop); mm++;
1451 while ( mm < mstop ) {
1452 if ( *mm != *r7 ) mm += mm[1];
1456 mstop = mm + mm[1]; mm += 2;
1458 && mm < mstop ) mm++;
1459 if ( mm >= mstop ) pow = 0;
1462 if ( pow == 0 )
break;
1465 if ( pow == 0 ) { t++;
continue; }
1482 if ( *t < 0 ) { *r1++ = -VECTOR; }
1483 else { *r1++ = -INDEX; }
1492 GETSTOP(mm,mstop); mm++;
1493 while ( mm < mstop ) {
1494 if ( *mm != *r7 ) mm += mm[1];
1497 mstop = mm + mm[1]; mm += 2;
1498 while ( mm < mstop &&
1499 *mm != *t ) mm += 1;
1510 else if ( *t >= FUNCTION ) {
1515 if ( *t >= FUNCTION &&
1516 functions[*t-FUNCTION].commute == 0 ) ncom = 0;
1520 while ( mm < t && ( *mm == DUMMYFUN
1521 || *mm == DUMMYTEN ) ) mm += mm[1];
1522 if ( mm < t ) { t += t[1];
continue; }
1524 mm = rnext; pow = 1;
1527 GETSTOP(mm,mstop); mm++;
1528 while ( mm < mstop ) {
1529 if ( *mm == *t && mm[1] == t[1] ) {
1530 for ( i = 2; i < t[1]; i++ ) {
1531 if ( mm[i] != t[i] )
break;
1534 { mm += mm[1];
goto nextmterm; }
1536 if ( ncom && *mm != DUMMYFUN && *mm != DUMMYTEN )
1540 if ( mm >= mstop ) pow = 0;
1541 if ( pow == 0 )
break;
1542nextmterm: mm = mnext;
1544 if ( pow == 0 ) { t += t[1];
continue; }
1549 *r1++ = t[1] + 4 + ARGHEAD;
1550 for ( i = 1; i < ARGHEAD; i++ ) *r1++ = 0;
1552 for ( i = 0; i < t[1]; i++ ) *r1++ = t[i];
1553 *r1++ = 1; *r1++ = 1; *r1++ = 3;
1560 GETSTOP(mm,mstop); mm++;
1561 while ( mm < mstop ) {
1562 if ( *mm == *t && mm[1] == t[1] ) {
1563 for ( i = 2; i < t[1]; i++ ) {
1564 if ( mm[i] != t[i] )
break;
1567 if ( functions[*t-FUNCTION].spec > 0 )
1577nextterm: mm = mnext;
1579 if ( functions[*t-FUNCTION].spec > 0 )
1597 t += *t;
if ( t[-1] > 0 ) { pow = 0;
break; }
1607 EAscrat = (UWORD *)(TermMalloc(
"execarg"));
1608 if ( t + *t == r3 )
goto oneterm;
1612 while ( --i >= 0 ) EAscrat[i] = r6[i];
1617 if ( AccumGCD(BHEAD EAscrat,&ngcd,(UWORD *)r6,i) )
goto execargerr;
1618 if ( ngcd == 3 && EAscrat[0] == 1 && EAscrat[1] == 1 )
break;
1621 if ( ngcd != 3 || EAscrat[0] != 1 || EAscrat[1] != 1 ) {
1622 if ( pow ) ngcd = -ngcd;
1623 t = r5; r9 = r1; *r1++ = t[-ARGHEAD]; *r1++ = 1;
1624 FILLARG(r1); ngcd = REDLENG(ngcd);
1628 while ( r7 < r6) *r1++ = *r7++;
1631 if ( DivRat(BHEAD (UWORD *)r6,i,EAscrat,ngcd,(UWORD *)r1,&nq) )
goto execargerr;
1634 r1 += i; *r1++ = nq; *r8 = r1-r8;
1637 ngcd = INCLENG(ngcd);
1639 if ( factor && *factor == 0 ) {}
1640 else if ( ( factor && factor[0] == 4 && factor[2] == 1
1641 && factor[3] == -3 ) || pow == 0 ) {
1642 r9 = r1; *r1++ = ARGHEAD+2+i; *r1++ = 0;
1643 FILLARG(r1); *r1++ = i+2;
1644 for ( j = 0; j < i; j++ ) *r1++ = EAscrat[j];
1646 if ( ToFast(r9,r9) ) r1 = r9+2;
1648 else if ( factor && factor[0] == 4 && factor[2] == 1
1649 && factor[3] > 0 && pow ) {
1650 if ( ngcd < 0 ) ngcd = -ngcd;
1651 *r1++ = -SNUMBER; *r1++ = -1;
1652 r9 = r1; *r1++ = ARGHEAD+2+i; *r1++ = 0;
1653 FILLARG(r1); *r1++ = i+2;
1654 for ( j = 0; j < i; j++ ) *r1++ = EAscrat[j];
1656 if ( ToFast(r9,r9) ) r1 = r9+2;
1659 if ( ngcd < 0 ) ngcd = -ngcd;
1660 if ( pow ) { *r1++ = -SNUMBER; *r1++ = -1; }
1661 if ( ngcd != 3 || EAscrat[0] != 1 || EAscrat[1] != 1 ) {
1662 r9 = r1; *r1++ = ARGHEAD+2+i; *r1++ = 0;
1663 FILLARG(r1); *r1++ = i+2;
1664 for ( j = 0; j < i; j++ ) *r1++ = EAscrat[j];
1666 if ( ToFast(r9,r9) ) r1 = r9+2;
1675 if ( factor == 0 || *factor > 2 ) {
1677 *r1++ = -SNUMBER; *r1++ = -1;
1680 t += *t; t[-1] = -t[-1];
1683 t = rr; *r1++ = *t++; *r1++ = 1; t++;
1685 while ( t < m ) *r1++ = *t++;
1688 TermFree(EAscrat,
"execarg");
1698 while ( t < r ) *r1++ = *t++;
1702 while ( t < r ) *r1++ = *t++;
1706 while ( --i >= 0 ) *t++ = *m++;
1707 if ( AT.WorkPointer < t ) AT.WorkPointer = t;
1712 AR.Cnumlhs = oldnumlhs;
1713 if ( action && Normalize(BHEAD term) )
goto execargerr;
1714 AT.WorkPointer = oldwork;
1715 if ( AT.WorkPointer < term + *term ) AT.WorkPointer = term + *term;
1716 AT.pWorkPointer = oldppointer;
1717 if ( GCDbuffer ) NumberFree(GCDbuffer,
"execarg");
1720 AT.WorkPointer = oldwork;
1721 AT.pWorkPointer = oldppointer;
1722 MLOCK(ErrorMessageLock);
1724 MUNLOCK(ErrorMessageLock);
1733WORD execterm(PHEAD WORD *term, WORD level)
1736 CBUF *C = cbuf+AM.rbufnum;
1737 WORD oldnumlhs = AR.Cnumlhs;
1738 WORD maxisat = C->lhs[level][2];
1740 WORD *oldworkpointer = AT.WorkPointer;
1742 WORD olddeferflag = AR.DeferFlag, tryterm = 0;
1745 AR.Cnumlhs = C->lhs[level][3];
1752 AN.FunSorts[AR.sLevel]->PolyFlag = ( AR.PolyFun != 0 ) ? AR.PolyFunType: 0;
1753 if ( AR.PolyFun == 0 ) { AN.FunSorts[AR.sLevel]->PolyFlag = 0; }
1754 else if ( AR.PolyFunType == 1 ) { AN.FunSorts[AR.sLevel]->PolyFlag = 1; }
1755 else if ( AR.PolyFunType == 2 ) {
1756 if ( AR.PolyFunExp == 2 ) AN.FunSorts[AR.sLevel]->PolyFlag = 1;
1757 else AN.FunSorts[AR.sLevel]->PolyFlag = 2;
1762 t1 = oldworkpointer;
1763 i = *term;
while ( --i >= 0 ) *t1++ = *term++;
1764 AT.WorkPointer = t1;
1765 if (
Generator(BHEAD oldworkpointer,level) )
goto exectermerr;
1769 if (
Generator(BHEAD term,level) )
goto exectermerr;
1772 if ( tryterm ) { TermFree(buffer1,
"buffer in sort statement"); tryterm = 0; }
1773 else { M_free((
void *)buffer1,
"buffer in sort statement"); }
1777 if (
EndSort(BHEAD (WORD *)((VOID *)(&buffer1)),2) < 0 )
goto exectermerr;
1778 tryterm = AN.tryterm; AN.tryterm = 0;
1780 }
while ( AR.Cnumlhs < maxisat );
1781 AR.Cnumlhs = oldnumlhs;
1782 AR.DeferFlag = olddeferflag;
1785 t1 = oldworkpointer;
1786 i = *term;
while ( --i >= 0 ) *t1++ = *term++;
1787 AT.WorkPointer = t1;
1788 if (
Generator(BHEAD oldworkpointer,level) )
goto exectermerr;
1790 if ( tryterm ) { TermFree(buffer1,
"buffer in term statement"); tryterm = 0; }
1791 else { M_free(buffer1,
"buffer in term statement"); }
1793 AT.WorkPointer = oldworkpointer;
1796 AT.WorkPointer = oldworkpointer;
1797 AR.DeferFlag = olddeferflag;
1798 MLOCK(ErrorMessageLock);
1799 MesCall(
"execterm");
1800 MUNLOCK(ErrorMessageLock);
1809int ArgumentImplode(PHEAD WORD *term, WORD *thelist)
1812 WORD *liststart, *liststop, *inlist;
1813 WORD *w, *t, *tend, *tstop, *tt, *ttstop, *ttt, ncount, i;
1815 liststop = thelist + thelist[1];
1816 liststart = thelist + 2;
1819 tstop = tend - ABS(tend[-1]);
1821 while ( t < tstop ) {
1822 if ( *t >= FUNCTION ) {
1824 while ( inlist < liststop && *inlist != *t ) inlist += inlist[1];
1825 if ( inlist < liststop ) {
1826 tt = t; ttstop = t + t[1]; w = AT.WorkPointer;
1827 for ( i = 0; i < FUNHEAD; i++ ) *w++ = *tt++;
1828 while ( tt < ttstop ) {
1830 if ( *tt == -SNUMBER && tt[1] == 0 ) {
1831 ncount = 1; ttt = tt; tt += 2;
1832 while ( tt < ttstop && *tt == -SNUMBER && tt[1] == 0 ) {
1837 if ( tt < ttstop && *tt == -SNUMBER && ( tt[1] == 1 || tt[1] == -1 ) ) {
1839 *w++ = (ncount+1) * tt[1];
1843 else if ( ( tt[0] == tt[ARGHEAD] + ARGHEAD )
1844 && ( ABS(tt[tt[0]-1]) == 3 )
1845 && ( tt[tt[0]-2] == 1 )
1846 && ( tt[tt[0]-3] == 1 ) ) {
1847 i = *tt; NCOPY(w,tt,i)
1851 else if ( *tt == -SYMBOL ) {
1859 *w++ = ncount+1; *w++ = 1; *w++ = 3;
1863 else if ( *tt <= -FUNCTION ) {
1864 *w++ = ARGHEAD+FUNHEAD+4;
1870 *w++ = ncount+1; *w++ = 1; *w++ = 3;
1874 while ( ttt < tt ) *w++ = *ttt++;
1875 if ( tt < ttstop && *tt == -SNUMBER ) {
1876 *w++ = *tt++; *w++ = *tt++;
1880 else if ( *tt <= -FUNCTION ) {
1883 else if ( *tt < 0 ) {
1888 i = *tt; NCOPY(w,tt,i)
1891 AT.WorkPointer[1] = w - AT.WorkPointer;
1892 while ( tt < tend ) *w++ = *tt++;
1893 ttt = AT.WorkPointer; tt = t;
1894 while ( ttt < w ) *tt++ = *ttt++;
1895 term[0] = tt - term;
1896 AT.WorkPointer = tt;
1897 tend = tt; tstop = tt - ABS(tt[-1]);
1903 if ( Normalize(BHEAD term) )
return(-1);
1913int ArgumentExplode(PHEAD WORD *term, WORD *thelist)
1916 WORD *liststart, *liststop, *inlist, *old;
1917 WORD *w, *t, *tend, *tstop, *tt, *ttstop, *ttt, ncount, i;
1920 liststop = thelist + thelist[1];
1921 liststart = thelist + 2;
1924 tstop = tend - ABS(tend[-1]);
1926 while ( t < tstop ) {
1927 if ( *t >= FUNCTION ) {
1929 while ( inlist < liststop && *inlist != *t ) inlist += inlist[1];
1930 if ( inlist < liststop ) {
1931 tt = t; ttstop = t + t[1]; w = AT.WorkPointer;
1932 for ( i = 0; i < FUNHEAD; i++ ) *w++ = *tt++;
1933 while ( tt < ttstop ) {
1934 if ( *tt == -SNUMBER && tt[1] != 0 ) {
1935 if ( tt[1] < AM.MaxTer/((WORD)
sizeof(WORD)*4)
1936 && tt[1] > -(AM.MaxTer/((WORD)
sizeof(WORD)*4))
1937 && ( tt[1] > 1 || tt[1] < -1 ) ) {
1938 ncount = ABS(tt[1]);
1939 while ( ncount > 1 ) {
1940 *w++ = -SNUMBER; *w++ = 0; ncount--;
1943 if ( tt[1] < 0 ) *w++ = -1;
1949 *w++ = *tt++; *w++ = *tt++;
1952 else if ( *tt <= -FUNCTION ) {
1955 else if ( *tt < 0 ) {
1959 else if ( tt[0] == tt[ARGHEAD]+ARGHEAD ) {
1960 ttt = tt + tt[0] - 1;
1961 i = (ABS(ttt[0])-1)/2;
1963TooMany: old = AN.currentTerm;
1964 AN.currentTerm = term;
1965 MesPrint(
"Too many arguments in output of ArgExplode");
1966 MesPrint(
"Term = %t");
1967 AN.currentTerm = old;
1970 if ( ttt[-1] != 1 )
goto NoExplode;
1972 if ( 2*x > (AT.WorkTop-w)-*term )
goto TooMany;
1974 while ( ncount > 0 ) {
1975 *w++ = -SNUMBER; *w++ = 0; ncount--;
1978 i = *tt; NCOPY(w,tt,i)
1983 i = *tt; NCOPY(w,tt,i)
1986 AT.WorkPointer[1] = w - AT.WorkPointer;
1987 while ( tt < tend ) *w++ = *tt++;
1988 ttt = AT.WorkPointer; tt = t;
1989 while ( ttt < w ) *tt++ = *ttt++;
1990 term[0] = tt - term;
1991 AT.WorkPointer = tt;
1992 tend = tt; tstop = tt - ABS(tt[-1]);
1998 if ( Normalize(BHEAD term) )
return(-1);
2024int ArgFactorize(PHEAD WORD *argin, WORD *argout)
2029 WORD *argfree, *argextra, *argcopy, *t, *tstop, *a, *a1, *a2;
2033 WORD startebuf = cbuf[AT.ebufnum].numrhs,oldword;
2034 WORD oldsorttype = AR.SortType, numargs;
2035 int error = 0, action = 0, i, ii, number, sign = 1;
2042 AR.SortType = SORTHIGHFIRST;
2043 if ( oldsorttype != AR.SortType ) {
2045 oldword = argin[*argin]; argin[*argin] = 0;
2049 if ( AN.ncmod != 0 ) {
2050 if ( AN.ncmod != 1 || ( (WORD)AN.cmod[0] < 0 ) ) {
2051 MLOCK(ErrorMessageLock);
2052 MesPrint(
"Factorization modulus a number, greater than a WORD not implemented.");
2053 MUNLOCK(ErrorMessageLock);
2057 MLOCK(ErrorMessageLock);
2058 MesCall(
"ArgFactorize");
2059 MUNLOCK(ErrorMessageLock);
2062 if ( !*t) { t = tstop;
continue; }
2067 EndSort(BHEAD argin+ARGHEAD,0);
2068 argin[*argin] = oldword;
2078 if ( a1[0] == -SNUMBER && ( a1[1] == 1 || a1[1] == -1 ) ) {
2079 if ( a1[1] == -1 ) { sign = -sign; a1[1] = 1; }
2081 a = t = a1+2;
while ( *t ) NEXTARG(t);
2083 t = a1; NCOPY(t,a,i);
2092 else if ( a1[0] == FUNHEAD+ARGHEAD+4 && a1[ARGHEAD] == FUNHEAD+4
2093 && a1[*a1-1] == 3 && a1[*a1-2] == 1 && a1[*a1-3] == 1
2094 && a1[ARGHEAD+1] >= FUNCTION ) {
2095 a = t = a1+*a1;
while ( *t ) NEXTARG(t);
2097 *a1 = -a1[ARGHEAD+1]; t = a1+1; NCOPY(t,a,i);
2103 if ( argfree == 0 ) {
2106 else if ( argfree[0] == ( argfree[ARGHEAD]+ARGHEAD ) ) {
2107 Normalize(BHEAD argfree+ARGHEAD);
2108 argfree[0] = argfree[ARGHEAD]+ARGHEAD;
2110 if ( ( argfree[0] == ARGHEAD+4 ) && ( argfree[ARGHEAD+3] == 3 )
2111 && ( argfree[ARGHEAD+1] == 1 ) && ( argfree[ARGHEAD+2] == 1 ) ) {
2121 t = argfree+ARGHEAD;
2128 EndSort(BHEAD argfree+ARGHEAD,0);
2129 t = argfree+ARGHEAD;
2130 while ( *t ) t += *t;
2131 *argfree = t - argfree;
2137 if ( ( number =
FindArg(BHEAD argfree) ) != 0 ) {
2138 if ( number > 0 ) t = cbuf[AT.fbufnum].rhs[number-1];
2139 else t = cbuf[AC.ffbufnum].rhs[-number-1];
2151 if ( *tstop == -SNUMBER && tstop[1] == -1 ) {
2152 sign = -sign; ii += 2;
2156 a = argout;
while ( *a ) NEXTARG(a);
2158 if ( sign == -1 ) { *a++ = -SNUMBER; *a++ = -1; *a = 0; sign = 1; }
2164 while ( ii > 0 ) { *--a1 = *--a2; ii--; }
2167 if ( *t == -SNUMBER && t[1] == -1 ) { t += 2; }
2168 else { COPY1ARG(a,t) }
2178 argcopy = TermMalloc(
"argcopy");
2179 for ( i = 0; i <= *argfree; i++ ) argcopy[i] = argfree[i];
2181 tstop = argfree + *argfree;
2184 t = argfree + ARGHEAD;
2185 while ( t < tstop ) {
2186 sumcommu += DoesCommu(t);
2189 if ( sumcommu > 1 ) {
2190 MesPrint(
"ERROR: Cannot factorize an argument with more than one noncommuting object");
2194 t = argfree + ARGHEAD;
2196 while ( t < tstop ) {
2197 if ( ( t[1] != SYMBOL ) && ( *t != (ABS(t[*t-1])+1) ) ) {
2203 t = argfree + ARGHEAD;
2204 argextra = AT.WorkPointer;
2206 while ( t < tstop ) {
2210 AR.SortType = oldsorttype;
2211 TermFree(argcopy,
"argcopy");
2212 if ( argfree != argin ) TermFree(argfree,
"argfree");
2213 MesCall(
"ArgFactorize");
2218 t += *t; argextra += *argextra;
2220 if (
EndSort(BHEAD argfree+ARGHEAD,0) ) { error = -2;
goto getout; }
2221 t = argfree + ARGHEAD;
2222 while ( *t > 0 ) t += *t;
2223 *argfree = t - argfree;
2231 while ( *a ) NEXTARG(a);
2233 MesCall(
"ArgFactorize");
2242 if ( error == 0 && action ) {
2243 a1 = a; NEXTARG(a1);
2245 CBUF *C = cbuf+AC.cbufnum;
2246 CBUF *CC = cbuf+AT.ebufnum;
2247 WORD *oldworkpointer = AT.WorkPointer;
2248 WORD *argcopy2 = TermMalloc(
"argcopy2"), *a1, *a2;
2249 a1 = a; a2 = argcopy2;
2252 if ( *a1 > -FUNCTION ) *a2++ = *a1++;
2253 *a2++ = *a1++; *a2 = 0;
2258 argextra = AT.WorkPointer;
2260 while ( t < tstop ) {
2261 if ( ConvertFromPoly(BHEAD t,argextra,numxsymbol,CC->numrhs-startebuf+numxsymbol
2262 ,startebuf-numxsymbol,1) <= 0 ) {
2263 TermFree(argcopy2,
"argcopy2");
2269 AT.WorkPointer = argextra + *argextra;
2273 if (
Generator(BHEAD argextra,C->numlhs) ) {
2274 TermFree(argcopy2,
"argcopy2");
2280 AT.WorkPointer = oldworkpointer;
2281 if (
EndSort(BHEAD a2+ARGHEAD,0) ) { error = -5;
goto getout; }
2282 t = a2+ARGHEAD;
while ( *t ) t += *t;
2283 *a2 = t - a2; a2[1] = 0; ZEROARG(a2);
2284 ToFast(a2,a2); NEXTARG(a2);
2288 a2 = argcopy2; a1 = a;
2291 TermFree(argcopy2,
"argcopy2");
2295 CC->numrhs = startebuf;
2298 for ( i = 0; i <= *argcopy; i++ ) a[i] = argcopy[i];
2308 if ( error == 0 && AN.ncmod == 0 ) {
2309 if (
InsertArg(BHEAD argcopy,a,0) < 0 ) { error = -1; }
2319 for ( i = 0; i < ii; i++ ) argcopy[i] = argout[i];
2322 if ( *a1 == -SNUMBER && a1[1] < 0 ) {
2323 sign = -sign; a1[1] = -a1[1];
2325 a2 = a1+2;
while ( *a2 ) NEXTARG(a2);
2326 i = a2-a1-2; a2 = a1+2;
2330 while ( *a1 ) NEXTARG(a1);
2334 if ( *a1 > 0 && *a1 == a1[ARGHEAD]+ARGHEAD && a1[*a1-1] < 0 ) {
2335 a1[*a1-1] = -a1[*a1-1]; sign = -sign;
2337 if ( *a1 == ARGHEAD+4 && a1[ARGHEAD+1] == 1 && a1[ARGHEAD+2] == 1 ) {
2338 a2 = a1+ARGHEAD+4;
while ( *a2 ) NEXTARG(a2);
2339 i = a2-a1-ARGHEAD-4; a2 = a1+ARGHEAD+4;
2344 while ( *a1 ) NEXTARG(a1);
2352 for ( i = 0; i < ii; i++ ) *a2++ = argcopy[i];
2354 if ( sign == -1 ) { *a2++ = -SNUMBER; *a2++ = -1; sign = 1; }
2357 TermFree(argcopy,
"argcopy");
2359 if ( argfree != argin ) TermFree(argfree,
"argfree");
2360 if ( oldsorttype != AR.SortType ) {
2361 AR.SortType = oldsorttype;
2366 oldword = a[*a]; a[*a] = 0;
2377 else { NEXTARG(a); }
2381 t = argout; numargs = 0;
2385 if ( *tt == ABS(t[-1])+1+ARGHEAD && sign == -1 ) { t[-1] = -t[-1]; sign = 1; }
2386 else if ( *tt == -SNUMBER && sign == -1 ) { tt[1] = -tt[1]; sign = 1; }
2390 *t++ = -SNUMBER; *t++ = -1; *t = 0; sign = 1; numargs++;
2401 t = argout; numargs = 0;
2402 while ( *t && *t != -SNUMBER && ( *t < 0 || ( ABS(t[*t-1]) != *t-1 ) ) ) {
2407 if ( numargs > 1 ) {
2410 x[0] = argout[-FUNHEAD];
2411 x[1] = argout[-FUNHEAD+1];
2412 x[2] = argout[-FUNHEAD+2];
2413 while ( *t ) { NEXTARG(t); }
2414 argout[-FUNHEAD] = SQRTFUNCTION;
2415 argout[-FUNHEAD+1] = t-argout+FUNHEAD;
2416 argout[-FUNHEAD+2] = 0;
2417 AT.WorkPointer = t+1;
2418 Lijst = AT.WorkPointer;
2419 for ( i = 0; i < numargs; i++ ) Lijst[i] = i;
2420 AT.WorkPointer += numargs;
2421 error = Symmetrize(BHEAD argout-FUNHEAD,Lijst,numargs,1,SYMMETRIC);
2422 AT.WorkPointer = Lijst;
2423 argout[-FUNHEAD] = x[0];
2424 argout[-FUNHEAD+1] = x[1];
2425 argout[-FUNHEAD+2] = x[2];
2430 tstop = argout;
while ( *tstop ) { NEXTARG(tstop); }
2431 t = argout; number = 0;
2434 if ( *tt == -SNUMBER ) {
2435 if ( number == 0 )
break;
2437 while ( tt > argout ) { *--t = *--tt; }
2438 argout[0] = -SNUMBER; argout[1] = x[0];
2441 else if ( *tt == ABS(t[-1])+1+ARGHEAD ) {
2442 if ( number == 0 )
break;
2444 for ( i = 0; i < ii; i++ ) tstop[i] = tt[i];
2445 while ( tt > argout ) { *--t = *--tt; }
2446 for ( i = 0; i < ii; i++ ) argout[i] = tstop[i];
2475 if ( AN.ncmod != 0 )
return(0);
2476 number = FindTree(AT.fbufnum,a);
2477 if ( number >= 0 )
return(number+1);
2478 number = FindTree(AC.ffbufnum,a);
2479 if ( number >= 0 )
return(-number-1);
2501 bufnum = AT.fbufnum;
2505 else if ( par == 1 ) {
2506 bufnum = AC.ffbufnum;
2509 else {
return(-1); }
2511 AddNtoC(bufnum,*argin,argin,1);
2513 a = argout;
while ( *a ) NEXTARG(a);
2517 return(InsTree(bufnum,C->numrhs));
2533 CBUF *C = cbuf + bufnum;
2535 LONG *weights = (LONG *)Malloc1(2*(C->numrhs+1)*
sizeof(LONG),
"CleanupArgCache");
2536 LONG w, whalf, *extraweights;
2537 WORD *a, *to, *from;
2539 for ( i = 1; i <= C->numrhs; i++ ) {
2540 weights[i] = ((LONG)i) * (boomlijst[i].
usage);
2545 extraweights = weights+C->numrhs+1;
2547 whalf = weights[C->numrhs/2+1];
2553 for ( i = 1; i <= C->numrhs; i++ ) {
2554 from = C->
rhs[i]; w = ((LONG)i) * (boomlijst[i].
usage);
2556 if ( i < C->numrhs-1 ) {
2561 j = C->
rhs[i+1] - from;
2566 else if ( to == from ) {
2567 to += *to + 1;
while ( *to ) NEXTARG(to); to++;
2570 a = from; a += *a+1;
while ( *a ) NEXTARG(a); a++;
2575 weights[k++] = boomlijst[i].
usage;
2585 ClearTree(AT.fbufnum);
2586 for ( i = 1; i <= k; i++ ) {
2587 InsTree(AT.fbufnum,i);
2588 boomlijst[i].
usage = weights[i];
2593 M_free(weights,
"CleanupArgCache");
2602int ArgSymbolMerge(WORD *t1, WORD *t2)
2604 WORD *t1e = t1+t1[1];
2605 WORD *t2e = t2+t2[1];
2609 while ( t1a < t1e && t2a < t2e ) {
2610 if ( *t1a < *t2a ) {
2611 if ( t1a[1] >= 0 ) {
2613 while ( t3 < t1e ) { t3[-2] = *t3; t3[-1] = t3[1]; t3 += 2; }
2618 else if ( *t1a > *t2a ) {
2619 if ( t2a[1] >= 0 ) t2a += 2;
2622 while ( t3 > t1a ) { *t3 = t3[-2]; t3[1] = t3[-1]; t3 -= 2; }
2629 if ( t2a[1] < t1a[1] ) t1a[1] = t2a[1];
2633 while ( t2a < t2e ) {
2640 while ( t1a < t1e ) {
2641 if ( t1a[1] >= 0 ) {
2643 while ( t3 < t1e ) { t3[-2] = *t3; t3[-1] = t3[1]; t3 += 2; }
2657int ArgDotproductMerge(WORD *t1, WORD *t2)
2659 WORD *t1e = t1+t1[1];
2660 WORD *t2e = t2+t2[1];
2664 while ( t1a < t1e && t2a < t2e ) {
2665 if ( *t1a < *t2a || ( *t1a == *t2a && t1a[1] < t2a[1] ) ) {
2666 if ( t1a[2] >= 0 ) {
2668 while ( t3 < t1e ) { t3[-3] = *t3; t3[-2] = t3[1]; t3[-1] = t3[2]; t3 += 3; }
2673 else if ( *t1a > *t2a || ( *t1a == *t2a && t1a[1] > t2a[1] ) ) {
2674 if ( t2a[2] >= 0 ) t2a += 3;
2677 while ( t3 > t1a ) { *t3 = t3[-3]; t3[1] = t3[-2]; t3[2] = t3[-1]; t3 -= 3; }
2685 if ( t2a[2] < t1a[2] ) t1a[2] = t2a[2];
2689 while ( t2a < t2e ) {
2697 while ( t1a < t1e ) {
2698 if ( t1a[2] >= 0 ) {
2700 while ( t3 < t1e ) { t3[-3] = *t3; t3[-2] = t3[1]; t3[-1] = t3[2]; t3 += 3; }
2728 WORD *t, *rnext, *r1, *r2, *r3, *r5, *r6, *r7, *r8, *r9;
2729 WORD pow, *mm, *mnext, *mstop, *argin2 = argin, *argin3 = argin, *argfree;
2732 r5 = t = argin + ARGHEAD;
2733 r3 = argin + *argin;
2747 if ( *t == DELTA || *t == VECTOR ) {
2748 r7 = t; r8 = t + t[1]; t += 2;
2754 GETSTOP(mm,mstop); mm++;
2755 while ( mm < mstop ) {
2756 if ( *mm != *r7 ) mm += mm[1];
2760 mstop = mm + mm[1]; mm += 2;
2761 while ( ( *mm != *t || mm[1] != t[1] )
2762 && mm < mstop ) mm += 2;
2763 if ( mm >= mstop ) pow = 0;
2766 if ( pow == 0 )
break;
2769 if ( pow == 0 ) { t += 2;
continue; }
2773 *r1++ = 8 + ARGHEAD;
2774 for ( j = 1; j < ARGHEAD; j++ ) *r1++ = 0;
2775 *r1++ = 8; *r1++ = *r7;
2776 *r1++ = 4; *r1++ = *t; *r1++ = t[1];
2777 *r1++ = 1; *r1++ = 1; *r1++ = 3;
2785 GETSTOP(mm,mstop); mm++;
2786 while ( mm < mstop ) {
2787 if ( *mm != *r7 ) mm += mm[1];
2790 mstop = mm + mm[1]; mm += 2;
2791 while ( mm < mstop && (
2792 *mm != *t || mm[1] != t[1] ) ) mm += 2;
2793 *mm = mm[1] = NOINDEX;
2796 *t = t[1] = NOINDEX;
2804 else if ( *t == INDEX ) {
2805 r7 = t; r8 = t + t[1]; t += 2;
2811 GETSTOP(mm,mstop); mm++;
2812 while ( mm < mstop ) {
2813 if ( *mm != *r7 ) mm += mm[1];
2817 mstop = mm + mm[1]; mm += 2;
2819 && mm < mstop ) mm++;
2820 if ( mm >= mstop ) pow = 0;
2823 if ( pow == 0 )
break;
2826 if ( pow == 0 ) { t++;
continue; }
2830 if ( *t < 0 ) { *r1++ = -VECTOR; }
2831 else { *r1++ = -INDEX; }
2841 GETSTOP(mm,mstop); mm++;
2842 while ( mm < mstop ) {
2843 if ( *mm != *r7 ) mm += mm[1];
2846 mstop = mm + mm[1]; mm += 2;
2847 while ( mm < mstop &&
2848 *mm != *t ) mm += 1;
2859 else if ( *t >= FUNCTION ) {
2864 if ( *t >= FUNCTION &&
2865 functions[*t-FUNCTION].commute == 0 ) ncom = 0;
2869 while ( mm < t && ( *mm == DUMMYFUN
2870 || *mm == DUMMYTEN ) ) mm += mm[1];
2871 if ( mm < t ) { t += t[1];
continue; }
2873 mm = rnext; pow = 1;
2876 GETSTOP(mm,mstop); mm++;
2877 while ( mm < mstop ) {
2878 if ( *mm == *t && mm[1] == t[1] ) {
2879 for ( i = 2; i < t[1]; i++ ) {
2880 if ( mm[i] != t[i] )
break;
2883 { mm += mm[1];
goto nextmterm; }
2885 if ( ncom && *mm != DUMMYFUN && *mm != DUMMYTEN )
2889 if ( mm >= mstop ) pow = 0;
2890 if ( pow == 0 )
break;
2891nextmterm: mm = mnext;
2893 if ( pow == 0 ) { t += t[1];
continue; }
2897 *r1++ = t[1] + 4 + ARGHEAD;
2898 for ( i = 1; i < ARGHEAD; i++ ) *r1++ = 0;
2900 for ( i = 0; i < t[1]; i++ ) *r1++ = t[i];
2901 *r1++ = 1; *r1++ = 1; *r1++ = 3;
2909 GETSTOP(mm,mstop); mm++;
2910 while ( mm < mstop ) {
2911 if ( *mm == *t && mm[1] == t[1] ) {
2912 for ( i = 2; i < t[1]; i++ ) {
2913 if ( mm[i] != t[i] )
break;
2916 if ( functions[*t-FUNCTION].spec > 0 )
2926nextterm: mm = mnext;
2928 if ( functions[*t-FUNCTION].spec > 0 )
2954 if ( *t == SYMBOL ) {
2962 *r2++ = SYMBOL; *r2++ = 2;
2964 t = rnext; rnext = rnext + *rnext;
2978 ArgSymbolMerge(r7,r8);
2991 if ( r8[1] < 0 ) { act = 1; pow += -r8[1]*(ARGHEAD+8); }
2992 else { pow += 2*r8[1]; }
2999 t = argin + ARGHEAD;
3005 if ( *t != SYMBOL ) { t += t[1];
continue; }
3006 r8 = r7+2; r9 = t + t[1]; t += 2;
3007 while ( ( t < r9 ) && ( r8 < r2 ) ) {
3009 t[1] -= r8[1]; t += 2; r8 += 2;
3023 r8 = r7+pow; i = r7[1];
3024 while ( --i >= 0 ) r8[i] = r7[i];
3028 for ( i = 0; i < r8[1]; i++ ) { *r1++ = -SYMBOL; *r1++ = *r8; }
3033 argin2 = TermMalloc(
"TakeArgContent2");
3038 r5 = argin2; *r5++ = 0; *r5++ = 0; FILLARG(r5);
3044 *r5++ = *t++ + r7[1];
3045 while ( t < r6 ) *r5++ = *t++;
3046 i = r7[1] - 2; r8 = r7+2;
3047 *r5++ = r7[0]; *r5++ = r7[1];
3048 while ( i > 0 ) { *r5++ = *r8++; *r5++ = -*r8++; i -= 2; }
3049 while ( t < rnext ) *r5++ = *t++;
3050 Normalize(BHEAD r9);
3054 *argin2 = r5-argin2;
3065 if (
EndSort(BHEAD t,0) < 0 )
goto Irreg;
3066 while ( *t ) t += *t;
3067 *argin2 = t - argin2;
3073 r8 = r7+pow; i = r7[1];
3074 while ( --i >= 0 ) r8[i] = r7[i];
3079 for ( i = 0; i < r8[1]; i++ ) { *r1++ = -SYMBOL; *r1++ = *r8; }
3082 for ( i = 0; i < -r8[1]; i++ ) {
3083 *r1++ = ARGHEAD+8; *r1++ = 0;
3085 *r1++ = 8; *r1++ = SYMBOL; *r1++ = 4; *r1++ = *r8;
3086 *r1++ = -1; *r1++ = 1; *r1++ = 1; *r1++ = 3;
3108 if ( *t == DOTPRODUCT ) {
3116 *r2++ = DOTPRODUCT; *r2++ = 2;
3118 t = rnext; rnext = rnext + *rnext;
3132 ArgDotproductMerge(r7,r8);
3145 if ( r8[2] < 0 ) { pow += -r8[2]*(ARGHEAD+9); }
3146 else { pow += r8[2]*(ARGHEAD+9); }
3154 argin3 = TermMalloc(
"TakeArgContent3");
3159 r5 = argin3; *r5++ = 0; *r5++ = 0; FILLARG(r5);
3165 *r5++ = *t++ + r7[1];
3166 while ( t < r6 ) *r5++ = *t++;
3167 i = r7[1] - 2; r8 = r7+2;
3168 *r5++ = r7[0]; *r5++ = r7[1];
3169 while ( i > 0 ) { *r5++ = *r8++; *r5++ = *r8++; *r5++ = -*r8++; i -= 3; }
3170 while ( t < rnext ) *r5++ = *t++;
3171 Normalize(BHEAD r9);
3175 *argin3 = r5-argin3;
3186 if (
EndSort(BHEAD t,0) < 0 )
goto Irreg;
3187 while ( *t ) t += *t;
3188 *argin3 = t - argin3;
3194 r8 = r7+pow; i = r7[1];
3195 while ( --i >= 0 ) r8[i] = r7[i];
3199 for ( i = ABS(r8[2]); i > 0; i-- ) {
3200 *r1++ = ARGHEAD+9; *r1++ = 0; FILLARG(r1);
3201 *r1++ = 9; *r1++ = DOTPRODUCT; *r1++ = 5; *r1++ = *r8;
3202 *r1++ = r8[1]; *r1++ = r8[2] < 0 ? -1: 1;
3203 *r1++ = 1; *r1++ = 1; *r1++ = 3;
3219 t = argin3 + ARGHEAD; pow = 1;
3225 t += *t; t[-1] = -t[-1];
3231 argfree = TermMalloc(
"TakeArgContent1");
3232 if ( AN.cmod != 0 ) {
3233 r1 =
MakeMod(BHEAD argin3,r1,argfree);
3246 if ( argin3 != argin2 ) TermFree(argin3,
"TakeArgContent3");
3247 if ( argin2 != argin ) TermFree(argin2,
"TakeArgContent2");
3250 MesPrint(
"Irregularity while sorting argument in TakeArgContent");
3251 if ( argin3 != argin2 ) TermFree(argin3,
"TakeArgContent3");
3252 if ( argin2 != argin ) TermFree(argin2,
"TakeArgContent2");
3273 UWORD *GCDbuffer, *GCDbuffer2, *LCMbuffer, *LCMb, *LCMc;
3274 WORD *r, *r1, *r2, *r3, *r4, *r5, *rnext, i, k, j;
3275 WORD kGCD, kLCM, kGCD2, kkLCM, jLCM, jGCD;
3276 GCDbuffer = NumberMalloc(
"MakeInteger");
3277 GCDbuffer2 = NumberMalloc(
"MakeInteger");
3278 LCMbuffer = NumberMalloc(
"MakeInteger");
3279 LCMb = NumberMalloc(
"MakeInteger");
3280 LCMc = NumberMalloc(
"MakeInteger");
3281 r4 = argin + *argin;
3282 r = argin + ARGHEAD;
3290 if ( k < 0 ) k = -k;
3291 while ( ( k > 1 ) && ( r3[k-1] == 0 ) ) k--;
3292 for ( kGCD = 0; kGCD < k; kGCD++ ) GCDbuffer[kGCD] = r3[kGCD];
3294 if ( k < 0 ) k = -k;
3296 while ( ( k > 1 ) && ( r3[k-1] == 0 ) ) k--;
3297 for ( kLCM = 0; kLCM < k; kLCM++ ) LCMbuffer[kLCM] = r3[kLCM];
3307 if ( k < 0 ) k = -k;
3308 while ( ( k > 1 ) && ( r3[k-1] == 0 ) ) k--;
3309 if ( ( ( GCDbuffer[0] == 1 ) && ( kGCD == 1 ) ) ) {
3314 else if ( ( ( k != 1 ) || ( r3[0] != 1 ) ) ) {
3315 if ( GcdLong(BHEAD GCDbuffer,kGCD,(UWORD *)r3,k,GCDbuffer2,&kGCD2) ) {
3316 NumberFree(GCDbuffer,
"MakeInteger");
3317 NumberFree(GCDbuffer2,
"MakeInteger");
3318 NumberFree(LCMbuffer,
"MakeInteger");
3319 NumberFree(LCMb,
"MakeInteger"); NumberFree(LCMc,
"MakeInteger");
3320 goto MakeIntegerErr;
3323 for ( i = 0; i < kGCD; i++ ) GCDbuffer[i] = GCDbuffer2[i];
3326 kGCD = 1; GCDbuffer[0] = 1;
3329 if ( k < 0 ) k = -k;
3331 while ( ( k > 1 ) && ( r3[k-1] == 0 ) ) k--;
3332 if ( ( ( LCMbuffer[0] == 1 ) && ( kLCM == 1 ) ) ) {
3333 for ( kLCM = 0; kLCM < k; kLCM++ )
3334 LCMbuffer[kLCM] = r3[kLCM];
3336 else if ( ( k != 1 ) || ( r3[0] != 1 ) ) {
3337 if ( GcdLong(BHEAD LCMbuffer,kLCM,(UWORD *)r3,k,LCMb,&kkLCM) ) {
3338 NumberFree(GCDbuffer,
"MakeInteger"); NumberFree(GCDbuffer2,
"MakeInteger");
3339 NumberFree(LCMbuffer,
"MakeInteger"); NumberFree(LCMb,
"MakeInteger"); NumberFree(LCMc,
"MakeInteger");
3340 goto MakeIntegerErr;
3342 DivLong((UWORD *)r3,k,LCMb,kkLCM,LCMb,&kkLCM,LCMc,&jLCM);
3343 MulLong(LCMbuffer,kLCM,LCMb,kkLCM,LCMc,&jLCM);
3344 for ( kLCM = 0; kLCM < jLCM; kLCM++ )
3345 LCMbuffer[kLCM] = LCMc[kLCM];
3353 r3 = (WORD *)(GCDbuffer);
3354 if ( kGCD == kLCM ) {
3355 for ( jGCD = 0; jGCD < kGCD; jGCD++ )
3356 r3[jGCD+kGCD] = LCMbuffer[jGCD];
3359 else if ( kGCD > kLCM ) {
3360 for ( jGCD = 0; jGCD < kLCM; jGCD++ )
3361 r3[jGCD+kGCD] = LCMbuffer[jGCD];
3362 for ( jGCD = kLCM; jGCD < kGCD; jGCD++ )
3367 for ( jGCD = kGCD; jGCD < kLCM; jGCD++ )
3369 for ( jGCD = 0; jGCD < kLCM; jGCD++ )
3370 r3[jGCD+kLCM] = LCMbuffer[jGCD];
3377 if ( ( j == 3 ) && ( r3[1] == 1 ) && ( (WORD)(r3[0]) > 0 ) ) {
3384 *r1++ = j+1+ARGHEAD; *r1++ = 0; FILLARG(r1);
3385 *r1++ = j+1; r2 = r3;
3386 for ( i = 0; i < k; i++ ) { *r1++ = *r2++; *r1++ = *r2++; }
3394 r2 = argfree + 2; FILLARG(r2)
3400 while ( r < r5 ) *r2++ = *r++;
3402 if ( DivRat(BHEAD (UWORD *)r5,j,GCDbuffer,k,(UWORD *)r2,&i) ) {
3403 goto MakeIntegerErr;
3407 if ( rnext[-1] < 0 ) r2[-1] = -i;
3413 argfree[0] = r2-argfree;
3418 NumberFree(LCMc,
"MakeInteger");
3419 NumberFree(LCMb,
"MakeInteger");
3420 NumberFree(LCMbuffer,
"MakeInteger");
3421 NumberFree(GCDbuffer2,
"MakeInteger");
3422 NumberFree(GCDbuffer,
"MakeInteger");
3426 MesCall(
"MakeInteger");
3442WORD *
MakeMod(PHEAD WORD *argin,WORD *argout,WORD *argfree)
3444 WORD *r, *instop, *r1, *m, x, xx, ix, ip;
3446 r = argin; instop = r + *r; r += ARGHEAD;
3448 if ( r[*r-1] < 0 ) x += AN.cmod[0];
3452 argout[0] = -SNUMBER;
3461 m = argfree + ARGHEAD;
3462 while ( r < instop ) {
3463 xx = r[*r-3];
if ( r[*r-1] < 0 ) xx += AN.cmod[0];
3464 xx = (WORD)((((LONG)xx)*ix) % AN.cmod[0]);
3466 i = *r; NCOPY(m,r,i);
3467 m[-3] = xx; m[-1] = 3;
3472 *argfree = m - argfree;
3474 argfree += 2; FILLARG(argfree);
3489 LONG w, *fill, *from1, *from2;
3491 if ( number >= 4 ) {
3492 n1 = number/2; n2 = number - n1;
3499 for ( i = 0; i < n1; i++ ) extraspace[i] = weights[i];
3500 fill = weights; from1 = extraspace; from2 = weights+n1;
3501 while ( n1 > 0 && n2 > 0 ) {
3502 if ( *from1 <= *from2 ) { *fill++ = *from1++; n1--; }
3503 else { *fill++ = *from2++; n2--; }
3505 while ( n1 > 0 ) { *fill++ = *from1++; n1--; }
3510 else if ( number == 3 ) {
3511 if ( weights[0] > weights[1] ) {
3512 if ( weights[1] > weights[2] ) {
3513 w = weights[0]; weights[0] = weights[2]; weights[2] = w;
3515 else if ( weights[0] > weights[2] ) {
3516 w = weights[0]; weights[0] = weights[1];
3517 weights[1] = weights[2]; weights[2] = w;
3520 w = weights[0]; weights[0] = weights[1]; weights[1] = w;
3523 else if ( weights[0] > weights[2] ) {
3524 w = weights[0]; weights[0] = weights[2];
3525 weights[2] = weights[1]; weights[1] = w;
3527 else if ( weights[1] > weights[2] ) {
3528 w = weights[1]; weights[1] = weights[2]; weights[2] = w;
3531 else if ( number == 2 ) {
3532 if ( weights[0] > weights[1] ) {
3533 w = weights[0]; weights[0] = weights[1]; weights[1] = w;
WORD * TakeArgContent(PHEAD WORD *argin, WORD *argout)
WORD InsertArg(PHEAD WORD *argin, WORD *argout, int par)
WORD * MakeMod(PHEAD WORD *argin, WORD *argout, WORD *argfree)
int CleanupArgCache(PHEAD WORD bufnum)
WORD * MakeInteger(PHEAD WORD *argin, WORD *argout, WORD *argfree)
void SortWeights(LONG *weights, LONG *extraspace, WORD number)
WORD FindArg(PHEAD WORD *a)
int LocalConvertToPoly(PHEAD WORD *, WORD *, WORD, WORD)
LONG EndSort(PHEAD WORD *, int)
#define ZeroFillRange(w, begin, end)
WORD Generator(PHEAD WORD *, WORD)
WORD StoreTerm(PHEAD WORD *)
int poly_factorize_argument(PHEAD WORD *, WORD *)
int GetModInverses(WORD, WORD, WORD *, WORD *)