32-bit (compare |)

Author: HenryHRich

jsrc/au.c

@@ -56,7 +56,8 @@ A jtfdef(J jt,I flag2,C id,I t,AF f1,AF f2,A fs,A gs,A hs,I flag,I m,I l,I r){A
  GAT0(z,INT,(VERBSIZE+SZI-1)>>LGSZI,0); v=FAV(z);  // allocate as fixed size, and as INT to avoid clearing the area, which will be all filled in
  AN(z)=0xdeadbeef;  // AN field of function is used for actual rank
  if(fs)INCORPRA(fs); if(gs)INCORPRA(gs); if(hs)INCORPRA(hs);   // indicate fgh are about to be incorporated, and raise
- v->localuse.clr[0]=v->localuse.clr[1]=v->localuse.clr[2]=v->localuse.clr[3]=0;  // clear the private field
+ memset(&v->localuse,0,sizeof(v->localuse));
+// obsolete  v->localuse.clr[0]=v->localuse.clr[1]=v->localuse.clr[2]=v->localuse.clr[3]=0;  // clear the private field
  v->valencefns[0]    =f1?f1:jtdomainerr1;  /* monad C function */
  v->valencefns[1]    =f2?f2:jtdomainerr2;  /* dyad  C function */
  v->fgh[0]     =fs;                  /* monad            */

jsrc/jtype.h

@@ -982,17 +982,17 @@ typedef struct {
  // the localuse fields are not freed or counted for space, as the f/g/h fields are.  They are for local optimizations only.
  union {
   // start with the larger localuse, which requires a second cacheline.  This is 16 bytes, the first 8 of which are in the excess (first) cacheline
-  I4 clr[4];   // used to init to 0 - extends the union for 32-bit
+// obsolete   I4 clr[4];   // used to init to 0 - extends the union for 32-bit
   struct {AF func; I parm;} boxcut0;  // for x <;.0 y  and  x (<;.0~ -~/"2)~ y, .parm is ~0 for first, 0 for second, and .func points to failover routine (seldom used).  func in first cacheline
-  I4 srank[4];   // for RANK conj, the signed ranks - extends the union in 32-bit
+  US srank[4];   // for RANK conj, the signed ranks
   // the rest do not require both cachelines in 64-bit
   struct {
    union {
     I filler;  // pad to cacheline
     A cachedloc;   //  for namerefs ('name'~), the locale address if the name is a direct named lookup (after the first reference)
    } lu0;
    // end of first cacheline, which is not used much during execution
-   union {  // 8 bytes in the second (main) cacheline
+   union {  // 8 bytes in the second (main) cacheline.  Aligned to 8-byte bdy even on 32-bit system
     D cct;  // for comparison tolerance, FIT conj  =!.n OR comparison combination (i.&1@:(e.[!.n])) OR [e. i. ([-.-.)]&n OR m&i[.:] the CCT, 0 for default (never in an actual prehash).  For 32-bit, this extends the union, but that's OK since it doesn't add a cacheline.
     struct {
      I4 cgerx; // For cyclic iterators, the index of the next gerund to execute.  Here to avoid conflict with cut
@@ -1025,8 +1025,19 @@ typedef struct {
 typedef struct {
  // the localuse fields are not freed or counted for space, as the f/g/h fields are.  They are for local optimizations only.
  union {  // 8 bytes in the second (main) cacheline
-  US uavandx[2];   // offset from start of va/va1tbl to VA/UA block for adocv [monad then dyad]
-  I forcetask;  // for t., the flags extracted from n.  Bits 0-7=thread pool; bit 8=worker thread only
+    D cct;  // for comparison tolerance, FIT conj  =!.n OR comparison combination (i.&1@:(e.[!.n])) OR [e. i. ([-.-.)]&n OR m&i[.:] the CCT, 0 for default (never in an actual prehash).  For 32-bit, this extends the union, but that's OK since it doesn't add a cacheline.
+    struct {
+     I4 cgerx; // For cyclic iterators, the index of the next gerund to execute.  Here to avoid conflict with cut
+     I4 cutn;  // for u;.n where n is nonzero, n.  u/. also goes through this code.  There could be cyclic iterators but not boxcut
+    } gercut;
+    VARPSA *redfn;  // for reductions (u/ u/\ u/\.) address of rps block (may be dummy block)
+    US uavandx[2];   // offset from start of va/va1tbl to VA/UA block for adocv [monad then dyad]
+    AF foldfn;  // for Fold final operator, pointer to the dyadic EP of the handler (xdefn or unquote)
+    A wvb;  // for u&.[:]v, the verb whose inverse is needed
+    I linkvb;  // for dyads ; (,<) ,&[:]<  indicates which function; for (compare[!.n] |), indicates which compare function
+    A cachedref;  //  for namerefs ('name'~), the cached value, or 0 if not cached
+    AF fork2hfn;   // for dyad fork that is NOT a comparison combination or jtintersect, the function to call to process h (might be in h@][)
+    I forcetask;  // for t., the flags extracted from n.  Bits 0-7=thread pool; bit 8=worker thread only
  } lu1;  // this is the high-use stuff in the second cacheline
  AF valencefns[2];   // function to call for monad,dayd
  A fgh[3];  // operands of modifiers.  h is used for forks and also as a storage spot for parms.  all 3 are freed when the V block is freed

jsrc/va.h

@@ -412,6 +412,21 @@ I name(I n,I m,void* RESTRICTI x,void* RESTRICTI y,void* RESTRICTI z,J jt){ \
   } \
   R EVOK; \
  }
+// support intolerant comparisons explicitly, with absolute value of y
+#define ACMP0ABS(f,Tz,Tx,Ty,pfx,pfx0)   \
+ AHDR2(f,B,Tx,Ty){D u,v;                                             \
+  if(jt->cct!=1.0){ \
+   if(n-1==0)  DQ(m, u=(D)*x++;       v=(D)*y++; v=ABS(v); *z=pfx(u,v); z++; )    \
+   else if(n-1<0)DQ(m, u=(D)*x++; DQC(n, v=(D)*y++; v=ABS(v); *z=pfx(u,v); z++;))    \
+   else      DQ(m, v=(D)*y++; v=ABS(v); DQ(n, u=(D)*x++; *z=pfx(u,v); z++;));   \
+  }else{ \
+   if(n-1==0)  DQ(m, u=(D)*x++;       v=(D)*y++; v=ABS(v); *z=u pfx0 v; z++; )    \
+   else if(n-1<0)DQ(m, u=(D)*x++; DQC(n, v=(D)*y++; v=ABS(v); *z=u pfx0 v; z++;))    \
+   else      DQ(m, v=(D)*y++; v=ABS(v); DQ(n, u=(D)*x++; *z=u pfx0 v; z++;));   \
+  } \
+  R EVOK; \
+ }
+
 
 
 // n and m are never 0.

jsrc/vcomp.c

@@ -337,6 +337,12 @@ ACMP0(leDD, B,D,D, TLE, <=  )
 ACMP0(ltDD, B,D,D, TLT, <  )
 ACMP0(neDD, B,D,D, TNE, != )
 ACMP0(eqDD, B,D,D, TEQ, ==  )
+ACMP0ABS(geabsDD, B,D,D, TGE, >=  )
+ACMP0ABS(gtabsDD, B,D,D, TGT, >  )
+ACMP0ABS(leabsDD, B,D,D, TLE, <=  )
+ACMP0ABS(ltabsDD, B,D,D, TLT, <  )
+ACMP0ABS(neabsDD, B,D,D, TNE, != )
+ACMP0ABS(eqabsDD, B,D,D, TEQ, ==  )
 
 APFX(gtII, B,I,I, CMPGT,,R EVOK;)
 APFX(geII, B,I,I, CMPGE,,R EVOK;)

test/g020a.ijs

@@ -164,8 +164,8 @@ a =. u"u |  NB. no prim support
 b =. u |  NB. tolerant
 c =. u!.0"u |  NB. intolerant, no prim
 d =. u!.0 |  NB. intolerant prim
-assert. (a -: b)/~ y
-assert. (c -: d)/~ y
+assert. (a -: b)"0/~ y
+assert. (c -: d)"0/~ y
 assert. (7!:2 'a~ x') > 2 * (7!:2 'b~ x')
 assert. (10000 (6!:2) 'b~ x') > 1.3 * (10000 (6!:2) 'd~ x')
 1 return.