Mercurial > hg > jgplsrc

comparison vcompsc.c @ 0:e0bbaa717f41 draft default tip

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
lol J
author Jordi Gutiérrez Hermoso <jordigh@octave.org>
date Mon, 25 Nov 2013 11:56:30 -0500
parents
children
comparison
equal deleted inserted replaced
-1:000000000000 0:e0bbaa717f41
1 /* Copyright 1990-2011, Jsoftware Inc. All rights reserved. */
2 /* License in license.txt. */
3 /* */
4 /* Verbs: Comparatives */
5 /* */
6 /* Special code for the following cases: */
7 /* comp i. 0: i.&0@:comp */
8 /* comp i. 1: i.&1@:comp */
9 /* comp i: 0: i:&0@:comp */
10 /* comp i: 1: i:&1@:comp */
11 /* [: + / comp + /@:comp */
12 /* [: +./ comp +./@:comp 1: e. comp */
13 /* 0: e. comp */
14 /* [: I. comp I.@:comp */
15 /* where comp is one of the following: */
16 /* = ~: < <: >: > E. e. */
17
18 #include "j.h"
19 #include "ve.h"
20 #include "vcomp.h"
21
22
23 #define INDF(f,T0,T1,F) \
24 static F2(f){I an,n,wn;T0*av,x;T1*wv,y; \
25 an=AN(a); av=(T0*)AV(a); \
26 wn=AN(w); wv=(T1*)AV(w); n=AR(a)&&AR(w)?MAX(an,wn):AR(a)?an:wn; \
27 if (!AR(a)){x=*av; DO(n, y=*wv++; if(F(x,y))R sc(i););} \
28 else if(!AR(w)){y=*wv; DO(n, x=*av++; if(F(x,y))R sc(i););} \
29 else { DO(n, x=*av++; y=*wv++; if(F(x,y))R sc(i););} \
30 R sc(n); \
31 }
32
33 #define JNDF(f,T0,T1,F) \
34 static F2(f){I an,n,wn;T0*av,x;T1*wv,y; \
35 an=AN(a); av=(T0*)AV(a); \
36 wn=AN(w); wv=(T1*)AV(w); n=AR(a)&&AR(w)?MAX(an,wn):AR(a)?an:wn; \
37 if (!AR(a)){x=*av; wv+=n; DO(n, y=*--wv; if(F(x,y))R sc(n-1-i););} \
38 else if(!AR(w)){y=*wv; av+=n; DO(n, x=*--av; if(F(x,y))R sc(n-1-i););} \
39 else {av+=n; wv+=n; DO(n, x=*--av; y=*--wv; if(F(x,y))R sc(n-1-i););} \
40 R sc(n); \
41 }
42
43 #define SUMF(f,T0,T1,F) \
44 static F2(f){I an,m=0,n,wn;T0*av,x;T1*wv,y; \
45 an=AN(a); av=(T0*)AV(a); \
46 wn=AN(w); wv=(T1*)AV(w); n=AR(a)&&AR(w)?MAX(an,wn):AR(a)?an:wn; \
47 if (!AR(a)){x=*av; DO(n, y=*wv++; if(F(x,y))++m;);} \
48 else if(!AR(w)){y=*wv; DO(n, x=*av++; if(F(x,y))++m;);} \
49 else { DO(n, x=*av++; y=*wv++; if(F(x,y))++m;);} \
50 R sc(m); \
51 }
52
53 #define ANYF(f,T0,T1,F) \
54 static F2(f){I an,n,wn;T0*av,x;T1*wv,y; \
55 an=AN(a); av=(T0*)AV(a); \
56 wn=AN(w); wv=(T1*)AV(w); n=AR(a)&&AR(w)?MAX(an,wn):AR(a)?an:wn; \
57 if (!AR(a)){x=*av; DO(n, y=*wv++; if(F(x,y))R one;);} \
58 else if(!AR(w)){y=*wv; DO(n, x=*av++; if(F(x,y))R one;);} \
59 else { DO(n, x=*av++; y=*wv++; if(F(x,y))R one;);} \
60 R zero; \
61 }
62
63 #define ALLF(f,T0,T1,F) \
64 static F2(f){I an,n,wn;T0*av,x;T1*wv,y; \
65 an=AN(a); av=(T0*)AV(a); \
66 wn=AN(w); wv=(T1*)AV(w); n=AR(a)&&AR(w)?MAX(an,wn):AR(a)?an:wn; \
67 if (!AR(a)){x=*av; DO(n, y=*wv++; if(!F(x,y))R zero;);} \
68 else if(!AR(w)){y=*wv; DO(n, x=*av++; if(!F(x,y))R zero;);} \
69 else { DO(n, x=*av++; y=*wv++; if(!F(x,y))R zero;);} \
70 R one; \
71 }
72
73 #define IFB1 \
74 {if(zu==zv){I m=zv-AV(z); RZ(z=ext(0,z)); zv=m+AV(z); zu=AN(z)+AV(z);} *zv++=i;}
75
76 #define IFBF(f,T0,T1,F) \
77 static F2(f){A z;I an,n,wn,*zu,*zv;T0*av,x;T1*wv,y; \
78 an=AN(a); av=(T0*)AV(a); \
79 wn=AN(w); wv=(T1*)AV(w); n=AR(a)&&AR(w)?MAX(an,wn):AR(a)?an:wn; \
80 RZ(z=exta(INT,1L,1L,MAX(22,n/8))); zv=AV(z); zu=zv+AN(z); \
81 if (!AR(a)){x=*av; DO(n, y=*wv++; if(F(x,y))IFB1;);} \
82 else if(!AR(w)){y=*wv; DO(n, x=*av++; if(F(x,y))IFB1;);} \
83 else { DO(n, x=*av++; y=*wv++; if(F(x,y))IFB1;);} \
84 AN(z)=*AS(z)=zv-AV(z); R z; \
85 }
86
87
88 /* Now define byte-parallel (4 bytes at a time) versions of above */
89
90 #define JNDBR(yy) if(r&&(y=yy))DO(r, if(yv[r-1-i])R sc(n-1-i););
91
92 #if SY_64
93 #define ASSIGNX(v) {x=*v; xv[1]=xv[2]=xv[3]=xv[4]=xv[5]=xv[6]=xv[7]=xv[0];}
94 #define INDB3 R sc( i*SZI+(yv[0]?0:yv[1]?1:yv[2]?2:yv[3]?3:yv[4]?4:yv[5]?5:yv[6]?6:7) );
95 #define JNDB3 R sc(n-1-(r+i*SZI+(yv[7]?0:yv[6]?1:yv[5]?2:yv[4]?3:yv[3]?4:yv[2]?5:yv[1]?6:7)));
96 #else
97 #define ASSIGNX(v) {x=*v; xv[1]=xv[2]=xv[3]=xv[0];}
98 #define INDB3 R sc( i*SZI+(yv[0]?0:yv[1]?1:yv[2]?2:3) );
99 #define JNDB3 R sc(n-1-(r+i*SZI+(yv[3]?0:yv[2]?1:yv[1]?2:3)));
100 #endif
101
102 #define INDB(f,T0,T1,F) \
103 static F2(f){B*xv,*yv;I an,*av,n,q,r,wn,*wv,x,y; \
104 an=AN(a); av=AV(a); \
105 wn=AN(w); wv=AV(w); n=AR(a)&&AR(w)?MAX(an,wn):AR(a)?an:wn; \
106 q=n/SZI; r=n%SZI; \
107 xv=(B*)&x; yv=(B*)&y; \
108 if (!AR(a)){ASSIGNX(av); DO(q, if(y=F(x, *wv++))INDB3;); y=F(x, *wv);} \
109 else if(!AR(w)){ASSIGNX(wv); DO(q, if(y=F(*av++,x ))INDB3;); y=F(*av,x );} \
110 else { DO(q, if(y=F(*av++,*wv++))INDB3;); y=F(*av,*wv);} \
111 if(y)DO(r, if(yv[i])R sc(i+q*SZI);); \
112 R sc(n); \
113 }
114
115 #define JNDB(f,T0,T1,F) \
116 static F2(f){B*xv,*yv;I an,*av,n,q,r,wn,*wv,x,y; \
117 an=AN(a); av=AV(a); \
118 wn=AN(w); wv=AV(w); n=AR(a)&&AR(w)?MAX(an,wn):AR(a)?an:wn; \
119 q=n/SZI; r=n%SZI; \
120 xv=(B*)&x; yv=(B*)&y; \
121 if (!AR(a)){ASSIGNX(av); wv+=q; JNDBR(F(x, *wv)); DO(q, if(y=F(x, *--wv))JNDB3;);} \
122 else if(!AR(w)){ASSIGNX(wv); av+=q; JNDBR(F(*av,x )); DO(q, if(y=F(*--av,x ))JNDB3;);} \
123 else {av+=q; wv+=q; JNDBR(F(*av,*wv)); DO(q, if(y=F(*--av,*--wv))JNDB3;);} \
124 R sc(n); \
125 }
126
127 #define SUMB(f,T0,T1,F) \
128 static F2(f){B*xv;I an,*av,n,p,q,r,r1,wn,*wv,x,z=0;UC*tu;UI t; \
129 an=AN(a); av=AV(a); \
130 wn=AN(w); wv=AV(w); n=AR(a)&&AR(w)?MAX(an,wn):AR(a)?an:wn; \
131 p=n/SZI; q=p/255; r=p%255; r1=n%SZI; \
132 xv=(B*)&x; tu=(UC*)&t; \
133 if (!AR(a)){ \
134 ASSIGNX(av); \
135 DO(q, t=0; DO(255, t+=F(x, *wv++);); DO(SZI,z+=tu[i];);); \
136 t=0; DO(r, t+=F(x, *wv++);); DO(SZI,z+=tu[i];); x=F(x, *wv); \
137 }else if(!AR(w)){ \
138 ASSIGNX(wv); \
139 DO(q, t=0; DO(255, t+=F(*av++,x );); DO(SZI,z+=tu[i];);); \
140 t=0; DO(r, t+=F(*av++,x );); DO(SZI,z+=tu[i];); x=F(*av,x ); \
141 }else{ \
142 DO(q, t=0; DO(255, t+=F(*av++,*wv++);); DO(SZI,z+=tu[i];);); \
143 t=0; DO(r, t+=F(*av++,*wv++);); DO(SZI,z+=tu[i];); x=F(*av,*wv); \
144 } \
145 DO(r1, z+=xv[i];); \
146 R sc(z); \
147 }
148
149 #define ANYB(f,T0,T1,F) \
150 static F2(f){B*xv; I an,*av,n,p,r1, wn,*wv,x; \
151 an=AN(a); av=AV(a); \
152 wn=AN(w); wv=AV(w); n=AR(a)&&AR(w)?MAX(an,wn):AR(a)?an:wn; \
153 p=n/SZI; r1=n%SZI;; \
154 xv=(B*)&x; \
155 if (!AR(a)){ASSIGNX(av); DO(p, if( F(x, *wv++))R one; ); x=F(x, *wv);} \
156 else if(!AR(w)){ASSIGNX(wv); DO(p, if( F(*av++,x ))R one; ); x=F(*av,x );} \
157 else { DO(p, if( F(*av++,*wv++))R one; ); x=F(*av,*wv);} \
158 DO(r1, if(xv[i])R one;); \
159 R zero; \
160 }
161
162 #define ALLB(f,T0,T1,F) \
163 static F2(f){B*xv;C*tv;I an,*av,n,p,r1,t,wn,*wv,x; \
164 an=AN(a); av=AV(a); \
165 wn=AN(w); wv=AV(w); n=AR(a)&&AR(w)?MAX(an,wn):AR(a)?an:wn; \
166 p=n/SZI; r1=n%SZI;; \
167 xv=(B*)&x; tv=(C*)&t; DO(SZI, tv[i]=1;); \
168 if (!AR(a)){ASSIGNX(av); DO(p, if(t!=F(x, *wv++))R zero;); x=F(x, *wv);} \
169 else if(!AR(w)){ASSIGNX(wv); DO(p, if(t!=F(*av++,x ))R zero;); x=F(*av,x );} \
170 else { DO(p, if(t!=F(*av++,*wv++))R zero;); x=F(*av,*wv);} \
171 DO(r1, if(!xv[i])R zero;); \
172 R one; \
173 }
174
175 #if SY_64
176 #define IFB3 \
177 {if(zu<zv){I c=zv-AV(z); RZ(z=ext(0,z)); zv=c+AV(z); zu=AV(z)+AN(z)-SZI;} \
178 if(yv[0])*zv++= m; \
179 if(yv[1])*zv++=1+m; \
180 if(yv[2])*zv++=2+m; \
181 if(yv[3])*zv++=3+m; \
182 if(yv[4])*zv++=4+m; \
183 if(yv[5])*zv++=5+m; \
184 if(yv[6])*zv++=6+m; \
185 if(yv[7])*zv++=7+m; \
186 }
187 #else
188 #define IFB3 \
189 {if(zu<zv){I c=zv-AV(z); RZ(z=ext(0,z)); zv=c+AV(z); zu=AV(z)+AN(z)-SZI;} \
190 switch(y){ \
191 case B0001: *zv++=3+m; break; \
192 case B0010: *zv++=2+m; break; \
193 case B0011: *zv++=2+m; *zv++=3+m; break; \
194 case B0100: *zv++=1+m; break; \
195 case B0101: *zv++=1+m; *zv++=3+m; break; \
196 case B0110: *zv++=1+m; *zv++=2+m; break; \
197 case B0111: *zv++=1+m; *zv++=2+m; *zv++=3+m; break; \
198 case B1000: *zv++=m; break; \
199 case B1001: *zv++=m; *zv++=3+m; break; \
200 case B1010: *zv++=m; *zv++=2+m; break; \
201 case B1011: *zv++=m; *zv++=2+m; *zv++=3+m; break; \
202 case B1100: *zv++=m; *zv++=1+m; break; \
203 case B1101: *zv++=m; *zv++=1+m; *zv++=3+m; break; \
204 case B1110: *zv++=m; *zv++=1+m; *zv++=2+m; break; \
205 case B1111: *zv++=m; *zv++=1+m; *zv++=2+m; *zv++=3+m; break; \
206 }}
207 #endif
208
209 #define IFBB(f,T0,T1,F) \
210 static F2(f){A z;B*xv,*yv;I an,*av,m=0,n,q,r,wn,*wv,x,y,*zu,*zv; \
211 an=AN(a); av=AV(a); \
212 wn=AN(w); wv=AV(w); n=AR(a)&&AR(w)?MAX(an,wn):AR(a)?an:wn; \
213 q=n/SZI; r=n%SZI; \
214 xv=(B*)&x; yv=(B*)&y; \
215 RZ(z=exta(INT,1L,1L,MAX(22,n/SZI))); zv=AV(z); zu=zv+AN(z)-SZI; \
216 if (!AR(a)){ASSIGNX(av); DO(q, if(y=F(x, *wv++))IFB3; m+=SZI;); y=F(x, *wv);} \
217 else if(!AR(w)){ASSIGNX(wv); DO(q, if(y=F(*av++,x ))IFB3; m+=SZI;); y=F(*av,x );} \
218 else { DO(q, if(y=F(*av++,*wv++))IFB3; m+=SZI;); y=F(*av,*wv);} \
219 if(r&&y){DO(SZI-r, yv[r+i]=0;); IFB3;}; \
220 AN(z)=*AS(z)=zv-AV(z); R z; \
221 }
222
223 INDB( i0eqBB,B,B,NE ) INDF( i0eqBI,B,I,ANE ) INDF( i0eqBD,B,D,TNEXD) /* = */
224 INDF( i0eqIB,I,B,ANE ) INDF( i0eqII,I,I,ANE ) INDF( i0eqID,I,D,TNEXD)
225 INDF( i0eqDB,D,B,TNEDX) INDF( i0eqDI,D,I,TNEDX) INDF( i0eqDD,D,D,TNE )
226
227 INDB( i1eqBB,B,B,EQ ) INDF( i1eqBI,B,I,AEQ ) INDF( i1eqBD,B,D,TEQXD)
228 INDF( i1eqIB,I,B,AEQ ) INDF( i1eqII,I,I,AEQ ) INDF( i1eqID,I,D,TEQXD)
229 INDF( i1eqDB,D,B,TEQDX) INDF( i1eqDI,D,I,TEQDX) INDF( i1eqDD,D,D,TEQ )
230
231 JNDB( j0eqBB,B,B,NE ) JNDF( j0eqBI,B,I,ANE ) JNDF( j0eqBD,B,D,TNEXD)
232 JNDF( j0eqIB,I,B,ANE ) JNDF( j0eqII,I,I,ANE ) JNDF( j0eqID,I,D,TNEXD)
233 JNDF( j0eqDB,D,B,TNEDX) JNDF( j0eqDI,D,I,TNEDX) JNDF( j0eqDD,D,D,TNE )
234
235 JNDB( j1eqBB,B,B,EQ ) JNDF( j1eqBI,B,I,AEQ ) JNDF( j1eqBD,B,D,TEQXD)
236 JNDF( j1eqIB,I,B,AEQ ) JNDF( j1eqII,I,I,AEQ ) JNDF( j1eqID,I,D,TEQXD)
237 JNDF( j1eqDB,D,B,TEQDX) JNDF( j1eqDI,D,I,TEQDX) JNDF( j1eqDD,D,D,TEQ )
238
239 SUMB(sumeqBB,B,B,EQ ) SUMF(sumeqBI,B,I,AEQ ) SUMF(sumeqBD,B,D,TEQXD)
240 SUMF(sumeqIB,I,B,AEQ ) SUMF(sumeqII,I,I,AEQ ) SUMF(sumeqID,I,D,TEQXD)
241 SUMF(sumeqDB,D,B,TEQDX) SUMF(sumeqDI,D,I,TEQDX) SUMF(sumeqDD,D,D,TEQ )
242
243 ANYB(anyeqBB,B,B,EQ ) ANYF(anyeqBI,B,I,AEQ ) ANYF(anyeqBD,B,D,TEQXD)
244 ANYF(anyeqIB,I,B,AEQ ) ANYF(anyeqII,I,I,AEQ ) ANYF(anyeqID,I,D,TEQXD)
245 ANYF(anyeqDB,D,B,TEQDX) ANYF(anyeqDI,D,I,TEQDX) ANYF(anyeqDD,D,D,TEQ )
246
247 ALLB(alleqBB,B,B,EQ ) ALLF(alleqBI,B,I,AEQ ) ALLF(alleqBD,B,D,TEQXD)
248 ALLF(alleqIB,I,B,AEQ ) ALLF(alleqII,I,I,AEQ ) ALLF(alleqID,I,D,TEQXD)
249 ALLF(alleqDB,D,B,TEQDX) ALLF(alleqDI,D,I,TEQDX) ALLF(alleqDD,D,D,TEQ )
250
251 IFBB(ifbeqBB,B,B,EQ ) IFBF(ifbeqBI,B,I,AEQ ) IFBF(ifbeqBD,B,D,TEQXD)
252 IFBF(ifbeqIB,I,B,AEQ ) IFBF(ifbeqII,I,I,AEQ ) IFBF(ifbeqID,I,D,TEQXD)
253 IFBF(ifbeqDB,D,B,TEQDX) IFBF(ifbeqDI,D,I,TEQDX) IFBF(ifbeqDD,D,D,TEQ )
254
255 INDB( i0neBB,B,B,EQ ) INDF( i0neBI,B,I,AEQ ) INDF( i0neBD,B,D,TEQXD) /* ~: */
256 INDF( i0neIB,I,B,AEQ ) INDF( i0neII,I,I,AEQ ) INDF( i0neID,I,D,TEQXD)
257 INDF( i0neDB,D,B,TEQDX) INDF( i0neDI,D,I,TEQDX) INDF( i0neDD,D,D,TEQ )
258
259 INDB( i1neBB,B,B,NE ) INDF( i1neBI,B,I,ANE ) INDF( i1neBD,B,D,TNEXD)
260 INDF( i1neIB,I,B,ANE ) INDF( i1neII,I,I,ANE ) INDF( i1neID,I,D,TNEXD)
261 INDF( i1neDB,D,B,TNEDX) INDF( i1neDI,D,I,TNEDX) INDF( i1neDD,D,D,TNE )
262
263 JNDB( j0neBB,B,B,EQ ) JNDF( j0neBI,B,I,AEQ ) JNDF( j0neBD,B,D,TEQXD)
264 JNDF( j0neIB,I,B,AEQ ) JNDF( j0neII,I,I,AEQ ) JNDF( j0neID,I,D,TEQXD)
265 JNDF( j0neDB,D,B,TEQDX) JNDF( j0neDI,D,I,TEQDX) JNDF( j0neDD,D,D,TEQ )
266
267 JNDB( j1neBB,B,B,NE ) JNDF( j1neBI,B,I,ANE ) JNDF( j1neBD,B,D,TNEXD)
268 JNDF( j1neIB,I,B,ANE ) JNDF( j1neII,I,I,ANE ) JNDF( j1neID,I,D,TNEXD)
269 JNDF( j1neDB,D,B,TNEDX) JNDF( j1neDI,D,I,TNEDX) JNDF( j1neDD,D,D,TNE )
270
271 SUMB(sumneBB,B,B,NE ) SUMF(sumneBI,B,I,ANE ) SUMF(sumneBD,B,D,TNEXD)
272 SUMF(sumneIB,I,B,ANE ) SUMF(sumneII,I,I,ANE ) SUMF(sumneID,I,D,TNEXD)
273 SUMF(sumneDB,D,B,TNEDX) SUMF(sumneDI,D,I,TNEDX) SUMF(sumneDD,D,D,TNE )
274
275 ANYB(anyneBB,B,B,NE ) ANYF(anyneBI,B,I,ANE ) ANYF(anyneBD,B,D,TNEXD)
276 ANYF(anyneIB,I,B,ANE ) ANYF(anyneII,I,I,ANE ) ANYF(anyneID,I,D,TNEXD)
277 ANYF(anyneDB,D,B,TNEDX) ANYF(anyneDI,D,I,TNEDX) ANYF(anyneDD,D,D,TNE )
278
279 ALLB(allneBB,B,B,NE ) ALLF(allneBI,B,I,ANE ) ALLF(allneBD,B,D,TNEXD)
280 ALLF(allneIB,I,B,ANE ) ALLF(allneII,I,I,ANE ) ALLF(allneID,I,D,TNEXD)
281 ALLF(allneDB,D,B,TNEDX) ALLF(allneDI,D,I,TNEDX) ALLF(allneDD,D,D,TNE )
282
283 IFBB(ifbneBB,B,B,NE ) IFBF(ifbneBI,B,I,ANE ) IFBF(ifbneBD,B,D,TNEXD)
284 IFBF(ifbneIB,I,B,ANE ) IFBF(ifbneII,I,I,ANE ) IFBF(ifbneID,I,D,TNEXD)
285 IFBF(ifbneDB,D,B,TNEDX) IFBF(ifbneDI,D,I,TNEDX) IFBF(ifbneDD,D,D,TNE )
286
287 INDB( i0ltBB,B,B,GE ) INDF( i0ltBI,B,I,AGE ) INDF( i0ltBD,B,D,TGEXD) /* < */
288 INDF( i0ltIB,I,B,AGE ) INDF( i0ltII,I,I,AGE ) INDF( i0ltID,I,D,TGEXD)
289 INDF( i0ltDB,D,B,TGEDX) INDF( i0ltDI,D,I,TGEDX) INDF( i0ltDD,D,D,TGE )
290
291 INDB( i1ltBB,B,B,LT ) INDF( i1ltBI,B,I,ALT ) INDF( i1ltBD,B,D,TLTXD)
292 INDF( i1ltIB,I,B,ALT ) INDF( i1ltII,I,I,ALT ) INDF( i1ltID,I,D,TLTXD)
293 INDF( i1ltDB,D,B,TLTDX) INDF( i1ltDI,D,I,TLTDX) INDF( i1ltDD,D,D,TLT )
294
295 JNDB( j0ltBB,B,B,GE ) JNDF( j0ltBI,B,I,AGE ) JNDF( j0ltBD,B,D,TGEXD)
296 JNDF( j0ltIB,I,B,AGE ) JNDF( j0ltII,I,I,AGE ) JNDF( j0ltID,I,D,TGEXD)
297 JNDF( j0ltDB,D,B,TGEDX) JNDF( j0ltDI,D,I,TGEDX) JNDF( j0ltDD,D,D,TGE )
298
299 JNDB( j1ltBB,B,B,LT ) JNDF( j1ltBI,B,I,ALT ) JNDF( j1ltBD,B,D,TLTXD)
300 JNDF( j1ltIB,I,B,ALT ) JNDF( j1ltII,I,I,ALT ) JNDF( j1ltID,I,D,TLTXD)
301 JNDF( j1ltDB,D,B,TLTDX) JNDF( j1ltDI,D,I,TLTDX) JNDF( j1ltDD,D,D,TLT )
302
303 SUMB(sumltBB,B,B,LT ) SUMF(sumltBI,B,I,ALT ) SUMF(sumltBD,B,D,TLTXD)
304 SUMF(sumltIB,I,B,ALT ) SUMF(sumltII,I,I,ALT ) SUMF(sumltID,I,D,TLTXD)
305 SUMF(sumltDB,D,B,TLTDX) SUMF(sumltDI,D,I,TLTDX) SUMF(sumltDD,D,D,TLT )
306
307 ANYB(anyltBB,B,B,LT ) ANYF(anyltBI,B,I,ALT ) ANYF(anyltBD,B,D,TLTXD)
308 ANYF(anyltIB,I,B,ALT ) ANYF(anyltII,I,I,ALT ) ANYF(anyltID,I,D,TLTXD)
309 ANYF(anyltDB,D,B,TLTDX) ANYF(anyltDI,D,I,TLTDX) ANYF(anyltDD,D,D,TLT )
310
311 ALLB(allltBB,B,B,LT ) ALLF(allltBI,B,I,ALT ) ALLF(allltBD,B,D,TLTXD)
312 ALLF(allltIB,I,B,ALT ) ALLF(allltII,I,I,ALT ) ALLF(allltID,I,D,TLTXD)
313 ALLF(allltDB,D,B,TLTDX) ALLF(allltDI,D,I,TLTDX) ALLF(allltDD,D,D,TLT )
314
315 IFBB(ifbltBB,B,B,LT ) IFBF(ifbltBI,B,I,ALT ) IFBF(ifbltBD,B,D,TLTXD)
316 IFBF(ifbltIB,I,B,ALT ) IFBF(ifbltII,I,I,ALT ) IFBF(ifbltID,I,D,TLTXD)
317 IFBF(ifbltDB,D,B,TLTDX) IFBF(ifbltDI,D,I,TLTDX) IFBF(ifbltDD,D,D,TLT )
318
319 INDB( i0leBB,B,B,GT ) INDF( i0leBI,B,I,AGT ) INDF( i0leBD,B,D,TGTXD) /* <: */
320 INDF( i0leIB,I,B,AGT ) INDF( i0leII,I,I,AGT ) INDF( i0leID,I,D,TGTXD)
321 INDF( i0leDB,D,B,TGTDX) INDF( i0leDI,D,I,TGTDX) INDF( i0leDD,D,D,TGT )
322
323 INDB( i1leBB,B,B,LE ) INDF( i1leBI,B,I,ALE ) INDF( i1leBD,B,D,TLEXD)
324 INDF( i1leIB,I,B,ALE ) INDF( i1leII,I,I,ALE ) INDF( i1leID,I,D,TLEXD)
325 INDF( i1leDB,D,B,TLEDX) INDF( i1leDI,D,I,TLEDX) INDF( i1leDD,D,D,TLE )
326
327 JNDB( j0leBB,B,B,GT ) JNDF( j0leBI,B,I,AGT ) JNDF( j0leBD,B,D,TGTXD)
328 JNDF( j0leIB,I,B,AGT ) JNDF( j0leII,I,I,AGT ) JNDF( j0leID,I,D,TGTXD)
329 JNDF( j0leDB,D,B,TGTDX) JNDF( j0leDI,D,I,TGTDX) JNDF( j0leDD,D,D,TGT )
330
331 JNDB( j1leBB,B,B,LE ) JNDF( j1leBI,B,I,ALE ) JNDF( j1leBD,B,D,TLEXD)
332 JNDF( j1leIB,I,B,ALE ) JNDF( j1leII,I,I,ALE ) JNDF( j1leID,I,D,TLEXD)
333 JNDF( j1leDB,D,B,TLEDX) JNDF( j1leDI,D,I,TLEDX) JNDF( j1leDD,D,D,TLE )
334
335 SUMB(sumleBB,B,B,LE ) SUMF(sumleBI,B,I,ALE ) SUMF(sumleBD,B,D,TLEXD)
336 SUMF(sumleIB,I,B,ALE ) SUMF(sumleII,I,I,ALE ) SUMF(sumleID,I,D,TLEXD)
337 SUMF(sumleDB,D,B,TLEDX) SUMF(sumleDI,D,I,TLEDX) SUMF(sumleDD,D,D,TLE )
338
339 ANYB(anyleBB,B,B,LE ) ANYF(anyleBI,B,I,ALE ) ANYF(anyleBD,B,D,TLEXD)
340 ANYF(anyleIB,I,B,ALE ) ANYF(anyleII,I,I,ALE ) ANYF(anyleID,I,D,TLEXD)
341 ANYF(anyleDB,D,B,TLEDX) ANYF(anyleDI,D,I,TLEDX) ANYF(anyleDD,D,D,TLE )
342
343 ALLB(allleBB,B,B,LE ) ALLF(allleBI,B,I,ALE ) ALLF(allleBD,B,D,TLEXD)
344 ALLF(allleIB,I,B,ALE ) ALLF(allleII,I,I,ALE ) ALLF(allleID,I,D,TLEXD)
345 ALLF(allleDB,D,B,TLEDX) ALLF(allleDI,D,I,TLEDX) ALLF(allleDD,D,D,TLE )
346
347 IFBB(ifbleBB,B,B,LE ) IFBF(ifbleBI,B,I,ALE ) IFBF(ifbleBD,B,D,TLEXD)
348 IFBF(ifbleIB,I,B,ALE ) IFBF(ifbleII,I,I,ALE ) IFBF(ifbleID,I,D,TLEXD)
349 IFBF(ifbleDB,D,B,TLEDX) IFBF(ifbleDI,D,I,TLEDX) IFBF(ifbleDD,D,D,TLE )
350
351 INDB( i0geBB,B,B,LT ) INDF( i0geBI,B,I,ALT ) INDF( i0geBD,B,D,TLTXD) /* >: */
352 INDF( i0geIB,I,B,ALT ) INDF( i0geII,I,I,ALT ) INDF( i0geID,I,D,TLTXD)
353 INDF( i0geDB,D,B,TLTDX) INDF( i0geDI,D,I,TLTDX) INDF( i0geDD,D,D,TLT )
354
355 INDB( i1geBB,B,B,GE ) INDF( i1geBI,B,I,AGE ) INDF( i1geBD,B,D,TGEXD)
356 INDF( i1geIB,I,B,AGE ) INDF( i1geII,I,I,AGE ) INDF( i1geID,I,D,TGEXD)
357 INDF( i1geDB,D,B,TGEDX) INDF( i1geDI,D,I,TGEDX) INDF( i1geDD,D,D,TGE )
358
359 JNDB( j0geBB,B,B,LT ) JNDF( j0geBI,B,I,ALT ) JNDF( j0geBD,B,D,TLTXD)
360 JNDF( j0geIB,I,B,ALT ) JNDF( j0geII,I,I,ALT ) JNDF( j0geID,I,D,TLTXD)
361 JNDF( j0geDB,D,B,TLTDX) JNDF( j0geDI,D,I,TLTDX) JNDF( j0geDD,D,D,TLT )
362
363 JNDB( j1geBB,B,B,GE ) JNDF( j1geBI,B,I,AGE ) JNDF( j1geBD,B,D,TGEXD)
364 JNDF( j1geIB,I,B,AGE ) JNDF( j1geII,I,I,AGE ) JNDF( j1geID,I,D,TGEXD)
365 JNDF( j1geDB,D,B,TGEDX) JNDF( j1geDI,D,I,TGEDX) JNDF( j1geDD,D,D,TGE )
366
367 SUMB(sumgeBB,B,B,GE ) SUMF(sumgeBI,B,I,AGE ) SUMF(sumgeBD,B,D,TGEXD)
368 SUMF(sumgeIB,I,B,AGE ) SUMF(sumgeII,I,I,AGE ) SUMF(sumgeID,I,D,TGEXD)
369 SUMF(sumgeDB,D,B,TGEDX) SUMF(sumgeDI,D,I,TGEDX) SUMF(sumgeDD,D,D,TGE )
370
371 ANYB(anygeBB,B,B,GE ) ANYF(anygeBI,B,I,AGE ) ANYF(anygeBD,B,D,TGEXD)
372 ANYF(anygeIB,I,B,AGE ) ANYF(anygeII,I,I,AGE ) ANYF(anygeID,I,D,TGEXD)
373 ANYF(anygeDB,D,B,TGEDX) ANYF(anygeDI,D,I,TGEDX) ANYF(anygeDD,D,D,TGE )
374
375 ALLB(allgeBB,B,B,GE ) ALLF(allgeBI,B,I,AGE ) ALLF(allgeBD,B,D,TGEXD)
376 ALLF(allgeIB,I,B,AGE ) ALLF(allgeII,I,I,AGE ) ALLF(allgeID,I,D,TGEXD)
377 ALLF(allgeDB,D,B,TGEDX) ALLF(allgeDI,D,I,TGEDX) ALLF(allgeDD,D,D,TGE )
378
379 IFBB(ifbgeBB,B,B,GE ) IFBF(ifbgeBI,B,I,AGE ) IFBF(ifbgeBD,B,D,TGEXD)
380 IFBF(ifbgeIB,I,B,AGE ) IFBF(ifbgeII,I,I,AGE ) IFBF(ifbgeID,I,D,TGEXD)
381 IFBF(ifbgeDB,D,B,TGEDX) IFBF(ifbgeDI,D,I,TGEDX) IFBF(ifbgeDD,D,D,TGE )
382
383 INDB( i0gtBB,B,B,LE ) INDF( i0gtBI,B,I,ALE ) INDF( i0gtBD,B,D,TLEXD) /* > */
384 INDF( i0gtIB,I,B,ALE ) INDF( i0gtII,I,I,ALE ) INDF( i0gtID,I,D,TLEXD)
385 INDF( i0gtDB,D,B,TLEDX) INDF( i0gtDI,D,I,TLEDX) INDF( i0gtDD,D,D,TLE )
386
387 INDB( i1gtBB,B,B,GT ) INDF( i1gtBI,B,I,AGT ) INDF( i1gtBD,B,D,TGTXD)
388 INDF( i1gtIB,I,B,AGT ) INDF( i1gtII,I,I,AGT ) INDF( i1gtID,I,D,TGTXD)
389 INDF( i1gtDB,D,B,TGTDX) INDF( i1gtDI,D,I,TGTDX) INDF( i1gtDD,D,D,TGT )
390
391 JNDB( j0gtBB,B,B,LE ) JNDF( j0gtBI,B,I,ALE ) JNDF( j0gtBD,B,D,TLEXD)
392 JNDF( j0gtIB,I,B,ALE ) JNDF( j0gtII,I,I,ALE ) JNDF( j0gtID,I,D,TLEXD)
393 JNDF( j0gtDB,D,B,TLEDX) JNDF( j0gtDI,D,I,TLEDX) JNDF( j0gtDD,D,D,TLE )
394
395 JNDB( j1gtBB,B,B,GT ) JNDF( j1gtBI,B,I,AGT ) JNDF( j1gtBD,B,D,TGTXD)
396 JNDF( j1gtIB,I,B,AGT ) JNDF( j1gtII,I,I,AGT ) JNDF( j1gtID,I,D,TGTXD)
397 JNDF( j1gtDB,D,B,TGTDX) JNDF( j1gtDI,D,I,TGTDX) JNDF( j1gtDD,D,D,TGT )
398
399 SUMB(sumgtBB,B,B,GT ) SUMF(sumgtBI,B,I,AGT ) SUMF(sumgtBD,B,D,TGTXD)
400 SUMF(sumgtIB,I,B,AGT ) SUMF(sumgtII,I,I,AGT ) SUMF(sumgtID,I,D,TGTXD)
401 SUMF(sumgtDB,D,B,TGTDX) SUMF(sumgtDI,D,I,TGTDX) SUMF(sumgtDD,D,D,TGT )
402
403 ALLB(allgtBB,B,B,GT ) ALLF(allgtBI,B,I,AGT ) ALLF(allgtBD,B,D,TGTXD)
404 ALLF(allgtIB,I,B,AGT ) ALLF(allgtII,I,I,AGT ) ALLF(allgtID,I,D,TGTXD)
405 ALLF(allgtDB,D,B,TGTDX) ALLF(allgtDI,D,I,TGTDX) ALLF(allgtDD,D,D,TGT )
406
407 ANYB(anygtBB,B,B,GT ) ANYF(anygtBI,B,I,AGT ) ANYF(anygtBD,B,D,TGTXD)
408 ANYF(anygtIB,I,B,AGT ) ANYF(anygtII,I,I,AGT ) ANYF(anygtID,I,D,TGTXD)
409 ANYF(anygtDB,D,B,TGTDX) ANYF(anygtDI,D,I,TGTDX) ANYF(anygtDD,D,D,TGT )
410
411 IFBB(ifbgtBB,B,B,GT ) IFBF(ifbgtBI,B,I,AGT ) IFBF(ifbgtBD,B,D,TGTXD)
412 IFBF(ifbgtIB,I,B,AGT ) IFBF(ifbgtII,I,I,AGT ) IFBF(ifbgtID,I,D,TGTXD)
413 IFBF(ifbgtDB,D,B,TGTDX) IFBF(ifbgtDI,D,I,TGTDX) IFBF(ifbgtDD,D,D,TGT )
414
415
416 static AF atcompxy[]={ /* table for (B01,INT,FL) vs. (B01,INT,FL) */
417 i0eqBB, i0eqBI, i0eqBD, i0eqIB, i0eqII, i0eqID, i0eqDB, i0eqDI, i0eqDD, /* 0 */
418 i0neBB, i0neBI, i0neBD, i0neIB, i0neII, i0neID, i0neDB, i0neDI, i0neDD,
419 i0ltBB, i0ltBI, i0ltBD, i0ltIB, i0ltII, i0ltID, i0ltDB, i0ltDI, i0ltDD,
420 i0leBB, i0leBI, i0leBD, i0leIB, i0leII, i0leID, i0leDB, i0leDI, i0leDD,
421 i0geBB, i0geBI, i0geBD, i0geIB, i0geII, i0geID, i0geDB, i0geDI, i0geDD,
422 i0gtBB, i0gtBI, i0gtBD, i0gtIB, i0gtII, i0gtID, i0gtDB, i0gtDI, i0gtDD,
423 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L,
424 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L,
425
426 i1eqBB, i1eqBI, i1eqBD, i1eqIB, i1eqII, i1eqID, i1eqDB, i1eqDI, i1eqDD, /* 1 */
427 i1neBB, i1neBI, i1neBD, i1neIB, i1neII, i1neID, i1neDB, i1neDI, i1neDD,
428 i1ltBB, i1ltBI, i1ltBD, i1ltIB, i1ltII, i1ltID, i1ltDB, i1ltDI, i1ltDD,
429 i1leBB, i1leBI, i1leBD, i1leIB, i1leII, i1leID, i1leDB, i1leDI, i1leDD,
430 i1geBB, i1geBI, i1geBD, i1geIB, i1geII, i1geID, i1geDB, i1geDI, i1geDD,
431 i1gtBB, i1gtBI, i1gtBD, i1gtIB, i1gtII, i1gtID, i1gtDB, i1gtDI, i1gtDD,
432 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L,
433 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L,
434
435 j0eqBB, j0eqBI, j0eqBD, j0eqIB, j0eqII, j0eqID, j0eqDB, j0eqDI, j0eqDD, /* 2 */
436 j0neBB, j0neBI, j0neBD, j0neIB, j0neII, j0neID, j0neDB, j0neDI, j0neDD,
437 j0ltBB, j0ltBI, j0ltBD, j0ltIB, j0ltII, j0ltID, j0ltDB, j0ltDI, j0ltDD,
438 j0leBB, j0leBI, j0leBD, j0leIB, j0leII, j0leID, j0leDB, j0leDI, j0leDD,
439 j0geBB, j0geBI, j0geBD, j0geIB, j0geII, j0geID, j0geDB, j0geDI, j0geDD,
440 j0gtBB, j0gtBI, j0gtBD, j0gtIB, j0gtII, j0gtID, j0gtDB, j0gtDI, j0gtDD,
441 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L,
442 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L,
443
444 j1eqBB, j1eqBI, j1eqBD, j1eqIB, j1eqII, j1eqID, j1eqDB, j1eqDI, j1eqDD, /* 3 */
445 j1neBB, j1neBI, j1neBD, j1neIB, j1neII, j1neID, j1neDB, j1neDI, j1neDD,
446 j1ltBB, j1ltBI, j1ltBD, j1ltIB, j1ltII, j1ltID, j1ltDB, j1ltDI, j1ltDD,
447 j1leBB, j1leBI, j1leBD, j1leIB, j1leII, j1leID, j1leDB, j1leDI, j1leDD,
448 j1geBB, j1geBI, j1geBD, j1geIB, j1geII, j1geID, j1geDB, j1geDI, j1geDD,
449 j1gtBB, j1gtBI, j1gtBD, j1gtIB, j1gtII, j1gtID, j1gtDB, j1gtDI, j1gtDD,
450 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L,
451 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L,
452
453 sumeqBB,sumeqBI,sumeqBD, sumeqIB,sumeqII,sumeqID, sumeqDB,sumeqDI,sumeqDD, /* 4 */
454 sumneBB,sumneBI,sumneBD, sumneIB,sumneII,sumneID, sumneDB,sumneDI,sumneDD,
455 sumltBB,sumltBI,sumltBD, sumltIB,sumltII,sumltID, sumltDB,sumltDI,sumltDD,
456 sumleBB,sumleBI,sumleBD, sumleIB,sumleII,sumleID, sumleDB,sumleDI,sumleDD,
457 sumgeBB,sumgeBI,sumgeBD, sumgeIB,sumgeII,sumgeID, sumgeDB,sumgeDI,sumgeDD,
458 sumgtBB,sumgtBI,sumgtBD, sumgtIB,sumgtII,sumgtID, sumgtDB,sumgtDI,sumgtDD,
459 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L,
460 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L,
461
462 anyeqBB,anyeqBI,anyeqBD, anyeqIB,anyeqII,anyeqID, anyeqDB,anyeqDI,anyeqDD, /* 5 */
463 anyneBB,anyneBI,anyneBD, anyneIB,anyneII,anyneID, anyneDB,anyneDI,anyneDD,
464 anyltBB,anyltBI,anyltBD, anyltIB,anyltII,anyltID, anyltDB,anyltDI,anyltDD,
465 anyleBB,anyleBI,anyleBD, anyleIB,anyleII,anyleID, anyleDB,anyleDI,anyleDD,
466 anygeBB,anygeBI,anygeBD, anygeIB,anygeII,anygeID, anygeDB,anygeDI,anygeDD,
467 anygtBB,anygtBI,anygtBD, anygtIB,anygtII,anygtID, anygtDB,anygtDI,anygtDD,
468 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L,
469 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L,
470
471 alleqBB,alleqBI,alleqBD, alleqIB,alleqII,alleqID, alleqDB,alleqDI,alleqDD, /* 6 */
472 allneBB,allneBI,allneBD, allneIB,allneII,allneID, allneDB,allneDI,allneDD,
473 allltBB,allltBI,allltBD, allltIB,allltII,allltID, allltDB,allltDI,allltDD,
474 allleBB,allleBI,allleBD, allleIB,allleII,allleID, allleDB,allleDI,allleDD,
475 allgeBB,allgeBI,allgeBD, allgeIB,allgeII,allgeID, allgeDB,allgeDI,allgeDD,
476 allgtBB,allgtBI,allgtBD, allgtIB,allgtII,allgtID, allgtDB,allgtDI,allgtDD,
477 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L,
478 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L,
479
480 ifbeqBB,ifbeqBI,ifbeqBD, ifbeqIB,ifbeqII,ifbeqID, ifbeqDB,ifbeqDI,ifbeqDD, /* 7 */
481 ifbneBB,ifbneBI,ifbneBD, ifbneIB,ifbneII,ifbneID, ifbneDB,ifbneDI,ifbneDD,
482 ifbltBB,ifbltBI,ifbltBD, ifbltIB,ifbltII,ifbltID, ifbltDB,ifbltDI,ifbltDD,
483 ifbleBB,ifbleBI,ifbleBD, ifbleIB,ifbleII,ifbleID, ifbleDB,ifbleDI,ifbleDD,
484 ifbgeBB,ifbgeBI,ifbgeBD, ifbgeIB,ifbgeII,ifbgeID, ifbgeDB,ifbgeDI,ifbgeDD,
485 ifbgtBB,ifbgtBI,ifbgtBD, ifbgtIB,ifbgtII,ifbgtID, ifbgtDB,ifbgtDI,ifbgtDD,
486 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L,
487 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L,
488 };
489
490 INDF( i0eqC,C,C,ANE) INDF( i0neC,C,C,AEQ)
491 INDF( i1eqC,C,C,AEQ) INDF( i1neC,C,C,ANE)
492 JNDF( j0eqC,C,C,ANE) JNDF( j0neC,C,C,AEQ)
493 JNDF( j1eqC,C,C,AEQ) JNDF( j1neC,C,C,ANE)
494 SUMF(sumeqC,C,C,AEQ) SUMF(sumneC,C,C,ANE)
495 ALLF(alleqC,C,C,AEQ) ALLF(allneC,C,C,ANE)
496 ANYF(anyeqC,C,C,AEQ) ANYF(anyneC,C,C,ANE)
497 IFBF(ifbeqC,C,C,AEQ) IFBF(ifbneC,C,C,ANE)
498
499 static AF atcompC[]={ /* table for LIT vs. LIT */
500 i0eqC, i0neC, 0L,0L,0L,0L,0L,0L,
501 i1eqC, i1neC, 0L,0L,0L,0L,0L,0L,
502 j0eqC, j0neC, 0L,0L,0L,0L,0L,0L,
503 j1eqC, j1neC, 0L,0L,0L,0L,0L,0L,
504 sumeqC, sumneC, 0L,0L,0L,0L,0L,0L,
505 anyeqC, anyneC, 0L,0L,0L,0L,0L,0L,
506 alleqC, allneC, 0L,0L,0L,0L,0L,0L,
507 ifbeqC, ifbneC, 0L,0L,0L,0L,0L,0L,
508 };
509
510 INDF( i0eqS,SB,SB,ANE) INDF( i0neS,SB,SB,AEQ)
511 INDF( i1eqS,SB,SB,AEQ) INDF( i1neS,SB,SB,ANE)
512 JNDF( j0eqS,SB,SB,ANE) JNDF( j0neS,SB,SB,AEQ)
513 JNDF( j1eqS,SB,SB,AEQ) JNDF( j1neS,SB,SB,ANE)
514 SUMF(sumeqS,SB,SB,AEQ) SUMF(sumneS,SB,SB,ANE)
515 ALLF(alleqS,SB,SB,AEQ) ALLF(allneS,SB,SB,ANE)
516 ANYF(anyeqS,SB,SB,AEQ) ANYF(anyneS,SB,SB,ANE)
517 IFBF(ifbeqS,SB,SB,AEQ) IFBF(ifbneS,SB,SB,ANE)
518
519 INDF( i0ltS,SB,SB,SBGE) INDF( i0leS,SB,SB,SBGT) INDF( i0geS,SB,SB,SBLT) INDF( i0gtS,SB,SB,SBLE)
520 INDF( i1ltS,SB,SB,SBLT) INDF( i1leS,SB,SB,SBLE) INDF( i1geS,SB,SB,SBGE) INDF( i1gtS,SB,SB,SBGT)
521 JNDF( j0ltS,SB,SB,SBGE) JNDF( j0leS,SB,SB,SBGT) JNDF( j0geS,SB,SB,SBLT) JNDF( j0gtS,SB,SB,SBLE)
522 JNDF( j1ltS,SB,SB,SBLT) JNDF( j1leS,SB,SB,SBLE) JNDF( j1geS,SB,SB,SBGE) JNDF( j1gtS,SB,SB,SBGT)
523 SUMF(sumltS,SB,SB,SBLT) SUMF(sumleS,SB,SB,SBLE) SUMF(sumgeS,SB,SB,SBGE) SUMF(sumgtS,SB,SB,SBGT)
524 ALLF(allltS,SB,SB,SBLT) ALLF(allleS,SB,SB,SBLE) ALLF(allgeS,SB,SB,SBGE) ALLF(allgtS,SB,SB,SBGT)
525 ANYF(anyltS,SB,SB,SBLT) ANYF(anyleS,SB,SB,SBLE) ANYF(anygeS,SB,SB,SBGE) ANYF(anygtS,SB,SB,SBGT)
526 IFBF(ifbltS,SB,SB,SBLT) IFBF(ifbleS,SB,SB,SBLE) IFBF(ifbgeS,SB,SB,SBGE) IFBF(ifbgtS,SB,SB,SBGT)
527
528
529 static AF atcompSB[]={ /* table for SBT vs. SBT */
530 i0eqS, i0neS, i0ltS, i0leS, i0geS, i0gtS, 0L,0L,
531 i1eqS, i1neS, i1ltS, i1leS, i1geS, i1gtS, 0L,0L,
532 j0eqS, j0neS, j0ltS, j0leS, j0geS, j0gtS, 0L,0L,
533 j1eqS, j1neS, j1ltS, j1leS, j1geS, j1gtS, 0L,0L,
534 sumeqS,sumneS,sumltS,sumleS,sumgeS,sumgtS, 0L,0L,
535 anyeqS,anyneS,anyltS,anyleS,anygeS,anygtS, 0L,0L,
536 alleqS,allneS,allltS,allleS,allgeS,allgtS, 0L,0L,
537 ifbeqS,ifbneS,ifbltS,ifbleS,ifbgeS,ifbgtS, 0L,0L,
538 };
539
540
541 static F2( jti0eps){R indexofsub( II0EPS,w,a);}
542 static F2( jti1eps){R indexofsub( II1EPS,w,a);}
543 static F2( jtj0eps){R indexofsub( IJ0EPS,w,a);}
544 static F2( jtj1eps){R indexofsub( IJ1EPS,w,a);}
545 static F2(jtsumeps){R indexofsub(ISUMEPS,w,a);}
546 static F2(jtanyeps){R indexofsub(IANYEPS,w,a);}
547 static F2(jtalleps){R indexofsub(IALLEPS,w,a);}
548 static F2(jtifbeps){R indexofsub(IIFBEPS,w,a);}
549
550 static AF atcompX[]={ /* table for any vs. any */
551 0L,0L,0L,0L,0L,0L, 0L, jti0eps,
552 0L,0L,0L,0L,0L,0L, jti1ebar, jti1eps,
553 0L,0L,0L,0L,0L,0L, 0L, jtj0eps,
554 0L,0L,0L,0L,0L,0L, 0L, jtj1eps,
555 0L,0L,0L,0L,0L,0L, jtsumebar, jtsumeps,
556 0L,0L,0L,0L,0L,0L, jtanyebar, jtanyeps,
557 0L,0L,0L,0L,0L,0L, 0L, jtalleps,
558 0L,0L,0L,0L,0L,0L, jtifbebar, jtifbeps,
559 };
560
561
562 /* f 0 1 2 3 4 5 6 7 */
563 /* m = ~: < <: >: > E. e. */
564 /* 0 f i. 0: 0 1 2 3 4 5 6 7 */
565 /* 1 f i. 1: 8 9 10 11 12 13 14 15 */
566 /* 2 f i: 0: 16 17 18 19 20 21 22 23 */
567 /* 3 f i: 1: 24 25 26 27 28 29 30 31 */
568 /* 4 [: + / f 32 33 34 35 36 37 38 39 */
569 /* 5 [: +./ f 40 41 42 43 44 45 46 47 */
570 /* 6 [: *./ f 48 49 50 51 52 53 54 55 */
571 /* 7 [: I. f 56 57 58 59 60 61 62 63 */
572
573 AF jtatcompf(J jt,A a,A w,A self){AF f;I ar,at,m,wr,wt;
574 RZ(a&&w);
575 at=AT(a); ar=AR(a);
576 wt=AT(w); wr=AR(w);
577 m=VAV(self)->flag%256;
578 if(1<ar||1<wr){if(32<=m&&m<=37||40<=m&&m<=45||48<=m&&m<=53)R(AF)jtfslashatg; RZ(7==m%8);}
579 ASSERT(AN(a)==AN(w)||!ar||!wr||5<m%8,EVLENGTH);
580 f=atcompX[m];
581 if(!f){
582 if(at&B01+INT+FL&&wt&B01+INT+FL)f=atcompxy[9*m+3*(at&B01?0:at&INT?1:2)+(wt&B01?0:wt&INT?1:2)];
583 else if(at&LIT&&wt&LIT) f=atcompC[m];
584 else if(at&SBT&&wt&SBT) f=atcompSB[m];
585 }
586 R f;
587 } /* function table look-up for comp i. 1: and i.&1@:comp etc. */
588