carray 2.0.1 → 3.0.0

data/ext/carray_kernels_bincmp.c

@@ -0,0 +1,4445 @@
+/* ---------------------------------------------------------------------------
+
+   carray_kernels.c -- GENERATED by ext/mkkernel.rb -- DO NOT EDIT
+
+   Kernel definitions live in mkkernel.rb (search for `MkKernel.reduce`).
+   Regenerate by running:
+
+     cd ext && ruby mkkernel.rb > carray_kernels.c
+
+   extconf.rb regenerates automatically when mkkernel.rb is touched.
+
+   --------------------------------------------------------------------------- */
+
+#include "carray.h"
+#include "ca_kernel_iterator.h"
+#include "ca_sort_kernels.h"   /* sort kernels: internal, not via the carray.h umbrella */
+#include "carray_internal.h"   /* ca_lazy_arena_*, ca_is_lazy_view (streaming reduce) */
+#include "ca_obj_face.h"       /* rb_ca_strip_face_value (Face ordering gate) */
+#include <math.h>
+#include <stdint.h>
+#include <stdlib.h>   /* qsort, mergesort (HAVE_MERGESORT) -- for :sort kind */
+
+/* MEMO_REDUCTION_FASTPATH_ENTITY_ONLY_GUARD Tier 2: CAStack identity is
+   probed by operation-table function pointer (obj_type is runtime-
+   assigned, so no CA_OBJ_STACK compile-time constant exists). */
+extern ca_operation_function_t ca_stack_func;
+/* BOOL2VAL: bool -> Ruby (Qtrue/Qfalse).  Used as ruby_scalar wrapper
+   for the all/any flat-reduction Ruby surface so `a.all` / `a.any`
+   return real true/false, not Integer 0/1.  (BOOL2OBJ already exists
+   but returns Integer per CArray's boolean-as-int convention.)  */
+#ifndef CARRAY_BOOL2VAL_DEFINED
+#define CARRAY_BOOL2VAL_DEFINED
+static inline VALUE BOOL2VAL (boolean8_t x) { return x ? Qtrue : Qfalse; }
+#endif
+
+#include "ca_op_powi.h"
+
+/* ===== bincmp feq ============================================ */
+
+static void
+ca_bincmp_feq_float32_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  float *q1 = (float *) ptr1, *q2 = (float *) ptr2;
+  float *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { 
+      float f1a = fabs((float64_t) *p1);
+      float f2a = fabs((float64_t) *p2);
+      float fmax = (f1a > f2a) ? f1a : f2a;
+      (*p3) = ( fabs(((float64_t) *p1)-( (float64_t) *p2)) <= fmax * FLT_EPSILON ) ? 1 : 0;
+     }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { 
+      float f1a = fabs((float64_t) *p1);
+      float f2a = fabs((float64_t) *p2);
+      float fmax = (f1a > f2a) ? f1a : f2a;
+      (*p3) = ( fabs(((float64_t) *p1)-( (float64_t) *p2)) <= fmax * FLT_EPSILON ) ? 1 : 0;
+     }
+    }
+  }
+}
+
+static void
+ca_bincmp_feq_float64_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  double *q1 = (double *) ptr1, *q2 = (double *) ptr2;
+  double *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { 
+      double f1a = fabs((float64_t) *p1);
+      double f2a = fabs((float64_t) *p2);
+      double fmax = (f1a > f2a) ? f1a : f2a;
+      (*p3) = ( fabs(((float64_t) *p1)-( (float64_t) *p2)) <= fmax * DBL_EPSILON ) ? 1 : 0;
+     }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { 
+      double f1a = fabs((float64_t) *p1);
+      double f2a = fabs((float64_t) *p2);
+      double fmax = (f1a > f2a) ? f1a : f2a;
+      (*p3) = ( fabs(((float64_t) *p1)-( (float64_t) *p2)) <= fmax * DBL_EPSILON ) ? 1 : 0;
+     }
+    }
+  }
+}
+
+ca_bincmp_func_t
+ca_bincmp_feq[CA_NTYPE] = {
+  ca_bincmp_not_implement,
+  ca_bincmp_not_implement,
+  ca_bincmp_not_implement,
+  ca_bincmp_not_implement,
+  ca_bincmp_not_implement,
+  ca_bincmp_not_implement,
+  ca_bincmp_not_implement,
+  ca_bincmp_not_implement,
+  ca_bincmp_not_implement,
+  ca_bincmp_not_implement,
+  ca_bincmp_feq_float32_t,
+  ca_bincmp_feq_float64_t,
+  ca_bincmp_not_implement,
+  ca_bincmp_not_implement,
+  ca_bincmp_not_implement,
+  ca_bincmp_not_implement,
+  ca_bincmp_not_implement,
+};
+
+VALUE rb_ca_feq (VALUE self, VALUE other)
+{
+  if ( ! rb_ca_test_castable(other) ) {
+    return rb_ca_binop_pass_to_other(self, other, rb_intern("feq"));
+  }
+  return rb_ca_call_bincmp(self, other, ca_bincmp_feq, 0.0);
+}
+
+/* ===== bincmp eq ============================================ */
+
+static void
+ca_bincmp_eq_fixlen (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  char *q1 = ptr1, *q2 = ptr2;
+  char *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t s1 = b1*i1, s2 = b2*i2, s3 = b3*i3;
+  ca_size_t k;
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*s1;
+        p2 = q2 + k*s2;
+        p3 = q3 + k*s3;
+        { (*p3) = ( b1 == b2 && (! memcmp(p1, p2, b1)) ); }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*s1;
+      p2 = q2 + k*s2;
+      p3 = q3 + k*s3;
+      { (*p3) = ( b1 == b2 && (! memcmp(p1, p2, b1)) ); }
+    }
+  }
+}
+
+static void
+ca_bincmp_eq_boolean8_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  boolean8_t *q1 = (boolean8_t *) ptr1, *q2 = (boolean8_t *) ptr2;
+  boolean8_t *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = ( (*p1) == (*p2) ); }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = ( (*p1) == (*p2) ); }
+    }
+  }
+}
+
+static void
+ca_bincmp_eq_int8_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  int8_t *q1 = (int8_t *) ptr1, *q2 = (int8_t *) ptr2;
+  int8_t *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = ( (*p1) == (*p2) ); }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = ( (*p1) == (*p2) ); }
+    }
+  }
+}
+
+static void
+ca_bincmp_eq_uint8_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  uint8_t *q1 = (uint8_t *) ptr1, *q2 = (uint8_t *) ptr2;
+  uint8_t *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = ( (*p1) == (*p2) ); }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = ( (*p1) == (*p2) ); }
+    }
+  }
+}
+
+static void
+ca_bincmp_eq_int16_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  int16_t *q1 = (int16_t *) ptr1, *q2 = (int16_t *) ptr2;
+  int16_t *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = ( (*p1) == (*p2) ); }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = ( (*p1) == (*p2) ); }
+    }
+  }
+}
+
+static void
+ca_bincmp_eq_uint16_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  uint16_t *q1 = (uint16_t *) ptr1, *q2 = (uint16_t *) ptr2;
+  uint16_t *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = ( (*p1) == (*p2) ); }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = ( (*p1) == (*p2) ); }
+    }
+  }
+}
+
+static void
+ca_bincmp_eq_int32_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  int32_t *q1 = (int32_t *) ptr1, *q2 = (int32_t *) ptr2;
+  int32_t *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = ( (*p1) == (*p2) ); }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = ( (*p1) == (*p2) ); }
+    }
+  }
+}
+
+static void
+ca_bincmp_eq_uint32_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  uint32_t *q1 = (uint32_t *) ptr1, *q2 = (uint32_t *) ptr2;
+  uint32_t *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = ( (*p1) == (*p2) ); }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = ( (*p1) == (*p2) ); }
+    }
+  }
+}
+
+static void
+ca_bincmp_eq_int64_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  int64_t *q1 = (int64_t *) ptr1, *q2 = (int64_t *) ptr2;
+  int64_t *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = ( (*p1) == (*p2) ); }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = ( (*p1) == (*p2) ); }
+    }
+  }
+}
+
+static void
+ca_bincmp_eq_uint64_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  uint64_t *q1 = (uint64_t *) ptr1, *q2 = (uint64_t *) ptr2;
+  uint64_t *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = ( (*p1) == (*p2) ); }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = ( (*p1) == (*p2) ); }
+    }
+  }
+}
+
+static void
+ca_bincmp_eq_float32_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  float *q1 = (float *) ptr1, *q2 = (float *) ptr2;
+  float *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = ( (*p1) == (*p2) ); }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = ( (*p1) == (*p2) ); }
+    }
+  }
+}
+
+static void
+ca_bincmp_eq_float64_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  double *q1 = (double *) ptr1, *q2 = (double *) ptr2;
+  double *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = ( (*p1) == (*p2) ); }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = ( (*p1) == (*p2) ); }
+    }
+  }
+}
+
+static void
+ca_bincmp_eq_VALUE (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  VALUE *q1 = (VALUE *) ptr1, *q2 = (VALUE *) ptr2;
+  VALUE *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = RTEST(rb_funcall((*p1), rb_intern("=="), 1, (*p2))) ? 1 : 0; }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = RTEST(rb_funcall((*p1), rb_intern("=="), 1, (*p2))) ? 1 : 0; }
+    }
+  }
+}
+
+static void
+ca_bincmp_eq_cmplx64_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  cmplx64_t *q1 = (cmplx64_t *) ptr1, *q2 = (cmplx64_t *) ptr2;
+  cmplx64_t *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = (*p1) == (*p2); }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = (*p1) == (*p2); }
+    }
+  }
+}
+
+static void
+ca_bincmp_eq_cmplx128_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  cmplx128_t *q1 = (cmplx128_t *) ptr1, *q2 = (cmplx128_t *) ptr2;
+  cmplx128_t *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = (*p1) == (*p2); }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = (*p1) == (*p2); }
+    }
+  }
+}
+
+ca_bincmp_func_t
+ca_bincmp_eq[CA_NTYPE] = {
+  ca_bincmp_eq_fixlen,
+  ca_bincmp_eq_boolean8_t,
+  ca_bincmp_eq_int8_t,
+  ca_bincmp_eq_uint8_t,
+  ca_bincmp_eq_int16_t,
+  ca_bincmp_eq_uint16_t,
+  ca_bincmp_eq_int32_t,
+  ca_bincmp_eq_uint32_t,
+  ca_bincmp_eq_int64_t,
+  ca_bincmp_eq_uint64_t,
+  ca_bincmp_eq_float32_t,
+  ca_bincmp_eq_float64_t,
+  ca_bincmp_not_implement,
+  ca_bincmp_eq_cmplx64_t,
+  ca_bincmp_eq_cmplx128_t,
+  ca_bincmp_not_implement,
+  ca_bincmp_eq_VALUE,
+};
+
+VALUE rb_ca_eq (VALUE self, VALUE other)
+{
+  if ( ! rb_ca_test_castable(other) ) {
+    return rb_ca_binop_pass_to_other(self, other, rb_intern("eq"));
+  }
+  return rb_ca_call_bincmp(self, other, ca_bincmp_eq, 0.0);
+}
+
+/* ===== bincmp ne ============================================ */
+
+static void
+ca_bincmp_ne_fixlen (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  char *q1 = ptr1, *q2 = ptr2;
+  char *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t s1 = b1*i1, s2 = b2*i2, s3 = b3*i3;
+  ca_size_t k;
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*s1;
+        p2 = q2 + k*s2;
+        p3 = q3 + k*s3;
+        { (*p3) = ( b1 != b2 || memcmp(p1, p2, b1) ); }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*s1;
+      p2 = q2 + k*s2;
+      p3 = q3 + k*s3;
+      { (*p3) = ( b1 != b2 || memcmp(p1, p2, b1) ); }
+    }
+  }
+}
+
+static void
+ca_bincmp_ne_boolean8_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  boolean8_t *q1 = (boolean8_t *) ptr1, *q2 = (boolean8_t *) ptr2;
+  boolean8_t *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = ( (*p1) != (*p2) ); }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = ( (*p1) != (*p2) ); }
+    }
+  }
+}
+
+static void
+ca_bincmp_ne_int8_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  int8_t *q1 = (int8_t *) ptr1, *q2 = (int8_t *) ptr2;
+  int8_t *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = ( (*p1) != (*p2) ); }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = ( (*p1) != (*p2) ); }
+    }
+  }
+}
+
+static void
+ca_bincmp_ne_uint8_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  uint8_t *q1 = (uint8_t *) ptr1, *q2 = (uint8_t *) ptr2;
+  uint8_t *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = ( (*p1) != (*p2) ); }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = ( (*p1) != (*p2) ); }
+    }
+  }
+}
+
+static void
+ca_bincmp_ne_int16_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  int16_t *q1 = (int16_t *) ptr1, *q2 = (int16_t *) ptr2;
+  int16_t *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = ( (*p1) != (*p2) ); }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = ( (*p1) != (*p2) ); }
+    }
+  }
+}
+
+static void
+ca_bincmp_ne_uint16_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  uint16_t *q1 = (uint16_t *) ptr1, *q2 = (uint16_t *) ptr2;
+  uint16_t *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = ( (*p1) != (*p2) ); }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = ( (*p1) != (*p2) ); }
+    }
+  }
+}
+
+static void
+ca_bincmp_ne_int32_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  int32_t *q1 = (int32_t *) ptr1, *q2 = (int32_t *) ptr2;
+  int32_t *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = ( (*p1) != (*p2) ); }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = ( (*p1) != (*p2) ); }
+    }
+  }
+}
+
+static void
+ca_bincmp_ne_uint32_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  uint32_t *q1 = (uint32_t *) ptr1, *q2 = (uint32_t *) ptr2;
+  uint32_t *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = ( (*p1) != (*p2) ); }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = ( (*p1) != (*p2) ); }
+    }
+  }
+}
+
+static void
+ca_bincmp_ne_int64_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  int64_t *q1 = (int64_t *) ptr1, *q2 = (int64_t *) ptr2;
+  int64_t *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = ( (*p1) != (*p2) ); }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = ( (*p1) != (*p2) ); }
+    }
+  }
+}
+
+static void
+ca_bincmp_ne_uint64_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  uint64_t *q1 = (uint64_t *) ptr1, *q2 = (uint64_t *) ptr2;
+  uint64_t *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = ( (*p1) != (*p2) ); }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = ( (*p1) != (*p2) ); }
+    }
+  }
+}
+
+static void
+ca_bincmp_ne_float32_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  float *q1 = (float *) ptr1, *q2 = (float *) ptr2;
+  float *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = ( (*p1) != (*p2) ); }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = ( (*p1) != (*p2) ); }
+    }
+  }
+}
+
+static void
+ca_bincmp_ne_float64_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  double *q1 = (double *) ptr1, *q2 = (double *) ptr2;
+  double *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = ( (*p1) != (*p2) ); }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = ( (*p1) != (*p2) ); }
+    }
+  }
+}
+
+static void
+ca_bincmp_ne_VALUE (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  VALUE *q1 = (VALUE *) ptr1, *q2 = (VALUE *) ptr2;
+  VALUE *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = RTEST(rb_funcall((*p1), rb_intern("=="), 1, (*p2))) ? 0 : 1; }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = RTEST(rb_funcall((*p1), rb_intern("=="), 1, (*p2))) ? 0 : 1; }
+    }
+  }
+}
+
+static void
+ca_bincmp_ne_cmplx64_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  cmplx64_t *q1 = (cmplx64_t *) ptr1, *q2 = (cmplx64_t *) ptr2;
+  cmplx64_t *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = (*p1) != (*p2); }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = (*p1) != (*p2); }
+    }
+  }
+}
+
+static void
+ca_bincmp_ne_cmplx128_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  cmplx128_t *q1 = (cmplx128_t *) ptr1, *q2 = (cmplx128_t *) ptr2;
+  cmplx128_t *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = (*p1) != (*p2); }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = (*p1) != (*p2); }
+    }
+  }
+}
+
+ca_bincmp_func_t
+ca_bincmp_ne[CA_NTYPE] = {
+  ca_bincmp_ne_fixlen,
+  ca_bincmp_ne_boolean8_t,
+  ca_bincmp_ne_int8_t,
+  ca_bincmp_ne_uint8_t,
+  ca_bincmp_ne_int16_t,
+  ca_bincmp_ne_uint16_t,
+  ca_bincmp_ne_int32_t,
+  ca_bincmp_ne_uint32_t,
+  ca_bincmp_ne_int64_t,
+  ca_bincmp_ne_uint64_t,
+  ca_bincmp_ne_float32_t,
+  ca_bincmp_ne_float64_t,
+  ca_bincmp_not_implement,
+  ca_bincmp_ne_cmplx64_t,
+  ca_bincmp_ne_cmplx128_t,
+  ca_bincmp_not_implement,
+  ca_bincmp_ne_VALUE,
+};
+
+VALUE rb_ca_ne (VALUE self, VALUE other)
+{
+  if ( ! rb_ca_test_castable(other) ) {
+    return rb_ca_binop_pass_to_other(self, other, rb_intern("ne"));
+  }
+  return rb_ca_call_bincmp(self, other, ca_bincmp_ne, 0.0);
+}
+
+/* ===== bincmp gt ============================================ */
+
+static void
+ca_bincmp_gt_fixlen (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  char *q1 = ptr1, *q2 = ptr2;
+  char *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t s1 = b1*i1, s2 = b2*i2, s3 = b3*i3;
+  ca_size_t k;
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*s1;
+        p2 = q2 + k*s2;
+        p3 = q3 + k*s3;
+        { 
+      int cmp = memcmp(p1, p2, b1 < b2 ? b1 : b2);
+      (*p3) = ( cmp > 0 || ( cmp == 0 && b1 > b2 ) );
+     }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*s1;
+      p2 = q2 + k*s2;
+      p3 = q3 + k*s3;
+      { 
+      int cmp = memcmp(p1, p2, b1 < b2 ? b1 : b2);
+      (*p3) = ( cmp > 0 || ( cmp == 0 && b1 > b2 ) );
+     }
+    }
+  }
+}
+
+static void
+ca_bincmp_gt_boolean8_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  boolean8_t *q1 = (boolean8_t *) ptr1, *q2 = (boolean8_t *) ptr2;
+  boolean8_t *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = ( (*p1) > (*p2) ); }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = ( (*p1) > (*p2) ); }
+    }
+  }
+}
+
+static void
+ca_bincmp_gt_int8_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  int8_t *q1 = (int8_t *) ptr1, *q2 = (int8_t *) ptr2;
+  int8_t *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = ( (*p1) > (*p2) ); }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = ( (*p1) > (*p2) ); }
+    }
+  }
+}
+
+static void
+ca_bincmp_gt_uint8_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  uint8_t *q1 = (uint8_t *) ptr1, *q2 = (uint8_t *) ptr2;
+  uint8_t *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = ( (*p1) > (*p2) ); }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = ( (*p1) > (*p2) ); }
+    }
+  }
+}
+
+static void
+ca_bincmp_gt_int16_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  int16_t *q1 = (int16_t *) ptr1, *q2 = (int16_t *) ptr2;
+  int16_t *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = ( (*p1) > (*p2) ); }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = ( (*p1) > (*p2) ); }
+    }
+  }
+}
+
+static void
+ca_bincmp_gt_uint16_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  uint16_t *q1 = (uint16_t *) ptr1, *q2 = (uint16_t *) ptr2;
+  uint16_t *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = ( (*p1) > (*p2) ); }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = ( (*p1) > (*p2) ); }
+    }
+  }
+}
+
+static void
+ca_bincmp_gt_int32_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  int32_t *q1 = (int32_t *) ptr1, *q2 = (int32_t *) ptr2;
+  int32_t *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = ( (*p1) > (*p2) ); }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = ( (*p1) > (*p2) ); }
+    }
+  }
+}
+
+static void
+ca_bincmp_gt_uint32_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  uint32_t *q1 = (uint32_t *) ptr1, *q2 = (uint32_t *) ptr2;
+  uint32_t *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = ( (*p1) > (*p2) ); }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = ( (*p1) > (*p2) ); }
+    }
+  }
+}
+
+static void
+ca_bincmp_gt_int64_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  int64_t *q1 = (int64_t *) ptr1, *q2 = (int64_t *) ptr2;
+  int64_t *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = ( (*p1) > (*p2) ); }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = ( (*p1) > (*p2) ); }
+    }
+  }
+}
+
+static void
+ca_bincmp_gt_uint64_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  uint64_t *q1 = (uint64_t *) ptr1, *q2 = (uint64_t *) ptr2;
+  uint64_t *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = ( (*p1) > (*p2) ); }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = ( (*p1) > (*p2) ); }
+    }
+  }
+}
+
+static void
+ca_bincmp_gt_float32_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  float *q1 = (float *) ptr1, *q2 = (float *) ptr2;
+  float *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = ( (*p1) > (*p2) ); }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = ( (*p1) > (*p2) ); }
+    }
+  }
+}
+
+static void
+ca_bincmp_gt_float64_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  double *q1 = (double *) ptr1, *q2 = (double *) ptr2;
+  double *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = ( (*p1) > (*p2) ); }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = ( (*p1) > (*p2) ); }
+    }
+  }
+}
+
+static void
+ca_bincmp_gt_VALUE (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  VALUE *q1 = (VALUE *) ptr1, *q2 = (VALUE *) ptr2;
+  VALUE *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = RTEST(rb_funcall((*p1), rb_intern(">"), 1, (*p2))) ? 1 : 0; }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = RTEST(rb_funcall((*p1), rb_intern(">"), 1, (*p2))) ? 1 : 0; }
+    }
+  }
+}
+
+ca_bincmp_func_t
+ca_bincmp_gt[CA_NTYPE] = {
+  ca_bincmp_gt_fixlen,
+  ca_bincmp_gt_boolean8_t,
+  ca_bincmp_gt_int8_t,
+  ca_bincmp_gt_uint8_t,
+  ca_bincmp_gt_int16_t,
+  ca_bincmp_gt_uint16_t,
+  ca_bincmp_gt_int32_t,
+  ca_bincmp_gt_uint32_t,
+  ca_bincmp_gt_int64_t,
+  ca_bincmp_gt_uint64_t,
+  ca_bincmp_gt_float32_t,
+  ca_bincmp_gt_float64_t,
+  ca_bincmp_not_implement,
+  ca_bincmp_not_implement,
+  ca_bincmp_not_implement,
+  ca_bincmp_not_implement,
+  ca_bincmp_gt_VALUE,
+};
+
+VALUE rb_ca_gt (VALUE self, VALUE other)
+{
+  if ( ! rb_ca_test_castable(other) ) {
+    return rb_ca_binop_pass_to_other(self, other, rb_intern("gt"));
+  }
+  return rb_ca_call_bincmp(self, other, ca_bincmp_gt, 0.0);
+}
+
+/* ===== bincmp lt ============================================ */
+
+static void
+ca_bincmp_lt_fixlen (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  char *q1 = ptr1, *q2 = ptr2;
+  char *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t s1 = b1*i1, s2 = b2*i2, s3 = b3*i3;
+  ca_size_t k;
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*s1;
+        p2 = q2 + k*s2;
+        p3 = q3 + k*s3;
+        { 
+      int cmp = memcmp(p1, p2, b1 < b2 ? b1 : b2);
+      (*p3) = ( cmp < 0 || ( cmp == 0 && b1 < b2 ) );
+     }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*s1;
+      p2 = q2 + k*s2;
+      p3 = q3 + k*s3;
+      { 
+      int cmp = memcmp(p1, p2, b1 < b2 ? b1 : b2);
+      (*p3) = ( cmp < 0 || ( cmp == 0 && b1 < b2 ) );
+     }
+    }
+  }
+}
+
+static void
+ca_bincmp_lt_boolean8_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  boolean8_t *q1 = (boolean8_t *) ptr1, *q2 = (boolean8_t *) ptr2;
+  boolean8_t *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = ( (*p1) < (*p2) ); }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = ( (*p1) < (*p2) ); }
+    }
+  }
+}
+
+static void
+ca_bincmp_lt_int8_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  int8_t *q1 = (int8_t *) ptr1, *q2 = (int8_t *) ptr2;
+  int8_t *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = ( (*p1) < (*p2) ); }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = ( (*p1) < (*p2) ); }
+    }
+  }
+}
+
+static void
+ca_bincmp_lt_uint8_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  uint8_t *q1 = (uint8_t *) ptr1, *q2 = (uint8_t *) ptr2;
+  uint8_t *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = ( (*p1) < (*p2) ); }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = ( (*p1) < (*p2) ); }
+    }
+  }
+}
+
+static void
+ca_bincmp_lt_int16_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  int16_t *q1 = (int16_t *) ptr1, *q2 = (int16_t *) ptr2;
+  int16_t *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = ( (*p1) < (*p2) ); }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = ( (*p1) < (*p2) ); }
+    }
+  }
+}
+
+static void
+ca_bincmp_lt_uint16_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  uint16_t *q1 = (uint16_t *) ptr1, *q2 = (uint16_t *) ptr2;
+  uint16_t *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = ( (*p1) < (*p2) ); }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = ( (*p1) < (*p2) ); }
+    }
+  }
+}
+
+static void
+ca_bincmp_lt_int32_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  int32_t *q1 = (int32_t *) ptr1, *q2 = (int32_t *) ptr2;
+  int32_t *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = ( (*p1) < (*p2) ); }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = ( (*p1) < (*p2) ); }
+    }
+  }
+}
+
+static void
+ca_bincmp_lt_uint32_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  uint32_t *q1 = (uint32_t *) ptr1, *q2 = (uint32_t *) ptr2;
+  uint32_t *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = ( (*p1) < (*p2) ); }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = ( (*p1) < (*p2) ); }
+    }
+  }
+}
+
+static void
+ca_bincmp_lt_int64_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  int64_t *q1 = (int64_t *) ptr1, *q2 = (int64_t *) ptr2;
+  int64_t *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = ( (*p1) < (*p2) ); }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = ( (*p1) < (*p2) ); }
+    }
+  }
+}
+
+static void
+ca_bincmp_lt_uint64_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  uint64_t *q1 = (uint64_t *) ptr1, *q2 = (uint64_t *) ptr2;
+  uint64_t *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = ( (*p1) < (*p2) ); }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = ( (*p1) < (*p2) ); }
+    }
+  }
+}
+
+static void
+ca_bincmp_lt_float32_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  float *q1 = (float *) ptr1, *q2 = (float *) ptr2;
+  float *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = ( (*p1) < (*p2) ); }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = ( (*p1) < (*p2) ); }
+    }
+  }
+}
+
+static void
+ca_bincmp_lt_float64_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  double *q1 = (double *) ptr1, *q2 = (double *) ptr2;
+  double *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = ( (*p1) < (*p2) ); }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = ( (*p1) < (*p2) ); }
+    }
+  }
+}
+
+static void
+ca_bincmp_lt_VALUE (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  VALUE *q1 = (VALUE *) ptr1, *q2 = (VALUE *) ptr2;
+  VALUE *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = RTEST(rb_funcall((*p1), rb_intern("<"), 1, (*p2))) ? 1 : 0; }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = RTEST(rb_funcall((*p1), rb_intern("<"), 1, (*p2))) ? 1 : 0; }
+    }
+  }
+}
+
+ca_bincmp_func_t
+ca_bincmp_lt[CA_NTYPE] = {
+  ca_bincmp_lt_fixlen,
+  ca_bincmp_lt_boolean8_t,
+  ca_bincmp_lt_int8_t,
+  ca_bincmp_lt_uint8_t,
+  ca_bincmp_lt_int16_t,
+  ca_bincmp_lt_uint16_t,
+  ca_bincmp_lt_int32_t,
+  ca_bincmp_lt_uint32_t,
+  ca_bincmp_lt_int64_t,
+  ca_bincmp_lt_uint64_t,
+  ca_bincmp_lt_float32_t,
+  ca_bincmp_lt_float64_t,
+  ca_bincmp_not_implement,
+  ca_bincmp_not_implement,
+  ca_bincmp_not_implement,
+  ca_bincmp_not_implement,
+  ca_bincmp_lt_VALUE,
+};
+
+VALUE rb_ca_lt (VALUE self, VALUE other)
+{
+  if ( ! rb_ca_test_castable(other) ) {
+    return rb_ca_binop_pass_to_other(self, other, rb_intern("lt"));
+  }
+  return rb_ca_call_bincmp(self, other, ca_bincmp_lt, 0.0);
+}
+
+/* ===== bincmp ge ============================================ */
+
+static void
+ca_bincmp_ge_fixlen (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  char *q1 = ptr1, *q2 = ptr2;
+  char *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t s1 = b1*i1, s2 = b2*i2, s3 = b3*i3;
+  ca_size_t k;
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*s1;
+        p2 = q2 + k*s2;
+        p3 = q3 + k*s3;
+        { 
+      int cmp = memcmp(p1, p2, b1 < b2 ? b1 : b2);
+      (*p3) = ( cmp > 0 || ( cmp == 0 && b1 >= b2 ) );
+     }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*s1;
+      p2 = q2 + k*s2;
+      p3 = q3 + k*s3;
+      { 
+      int cmp = memcmp(p1, p2, b1 < b2 ? b1 : b2);
+      (*p3) = ( cmp > 0 || ( cmp == 0 && b1 >= b2 ) );
+     }
+    }
+  }
+}
+
+static void
+ca_bincmp_ge_boolean8_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  boolean8_t *q1 = (boolean8_t *) ptr1, *q2 = (boolean8_t *) ptr2;
+  boolean8_t *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = ( (*p1) >= (*p2) ); }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = ( (*p1) >= (*p2) ); }
+    }
+  }
+}
+
+static void
+ca_bincmp_ge_int8_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  int8_t *q1 = (int8_t *) ptr1, *q2 = (int8_t *) ptr2;
+  int8_t *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = ( (*p1) >= (*p2) ); }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = ( (*p1) >= (*p2) ); }
+    }
+  }
+}
+
+static void
+ca_bincmp_ge_uint8_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  uint8_t *q1 = (uint8_t *) ptr1, *q2 = (uint8_t *) ptr2;
+  uint8_t *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = ( (*p1) >= (*p2) ); }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = ( (*p1) >= (*p2) ); }
+    }
+  }
+}
+
+static void
+ca_bincmp_ge_int16_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  int16_t *q1 = (int16_t *) ptr1, *q2 = (int16_t *) ptr2;
+  int16_t *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = ( (*p1) >= (*p2) ); }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = ( (*p1) >= (*p2) ); }
+    }
+  }
+}
+
+static void
+ca_bincmp_ge_uint16_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  uint16_t *q1 = (uint16_t *) ptr1, *q2 = (uint16_t *) ptr2;
+  uint16_t *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = ( (*p1) >= (*p2) ); }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = ( (*p1) >= (*p2) ); }
+    }
+  }
+}
+
+static void
+ca_bincmp_ge_int32_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  int32_t *q1 = (int32_t *) ptr1, *q2 = (int32_t *) ptr2;
+  int32_t *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = ( (*p1) >= (*p2) ); }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = ( (*p1) >= (*p2) ); }
+    }
+  }
+}
+
+static void
+ca_bincmp_ge_uint32_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  uint32_t *q1 = (uint32_t *) ptr1, *q2 = (uint32_t *) ptr2;
+  uint32_t *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = ( (*p1) >= (*p2) ); }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = ( (*p1) >= (*p2) ); }
+    }
+  }
+}
+
+static void
+ca_bincmp_ge_int64_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  int64_t *q1 = (int64_t *) ptr1, *q2 = (int64_t *) ptr2;
+  int64_t *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = ( (*p1) >= (*p2) ); }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = ( (*p1) >= (*p2) ); }
+    }
+  }
+}
+
+static void
+ca_bincmp_ge_uint64_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  uint64_t *q1 = (uint64_t *) ptr1, *q2 = (uint64_t *) ptr2;
+  uint64_t *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = ( (*p1) >= (*p2) ); }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = ( (*p1) >= (*p2) ); }
+    }
+  }
+}
+
+static void
+ca_bincmp_ge_float32_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  float *q1 = (float *) ptr1, *q2 = (float *) ptr2;
+  float *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = ( (*p1) >= (*p2) ); }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = ( (*p1) >= (*p2) ); }
+    }
+  }
+}
+
+static void
+ca_bincmp_ge_float64_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  double *q1 = (double *) ptr1, *q2 = (double *) ptr2;
+  double *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = ( (*p1) >= (*p2) ); }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = ( (*p1) >= (*p2) ); }
+    }
+  }
+}
+
+static void
+ca_bincmp_ge_VALUE (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  VALUE *q1 = (VALUE *) ptr1, *q2 = (VALUE *) ptr2;
+  VALUE *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = RTEST(rb_funcall((*p1), rb_intern(">="), 1, (*p2))) ? 1 : 0; }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = RTEST(rb_funcall((*p1), rb_intern(">="), 1, (*p2))) ? 1 : 0; }
+    }
+  }
+}
+
+ca_bincmp_func_t
+ca_bincmp_ge[CA_NTYPE] = {
+  ca_bincmp_ge_fixlen,
+  ca_bincmp_ge_boolean8_t,
+  ca_bincmp_ge_int8_t,
+  ca_bincmp_ge_uint8_t,
+  ca_bincmp_ge_int16_t,
+  ca_bincmp_ge_uint16_t,
+  ca_bincmp_ge_int32_t,
+  ca_bincmp_ge_uint32_t,
+  ca_bincmp_ge_int64_t,
+  ca_bincmp_ge_uint64_t,
+  ca_bincmp_ge_float32_t,
+  ca_bincmp_ge_float64_t,
+  ca_bincmp_not_implement,
+  ca_bincmp_not_implement,
+  ca_bincmp_not_implement,
+  ca_bincmp_not_implement,
+  ca_bincmp_ge_VALUE,
+};
+
+VALUE rb_ca_ge (VALUE self, VALUE other)
+{
+  if ( ! rb_ca_test_castable(other) ) {
+    return rb_ca_binop_pass_to_other(self, other, rb_intern("ge"));
+  }
+  return rb_ca_call_bincmp(self, other, ca_bincmp_ge, 0.0);
+}
+
+/* ===== bincmp le ============================================ */
+
+static void
+ca_bincmp_le_fixlen (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  char *q1 = ptr1, *q2 = ptr2;
+  char *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t s1 = b1*i1, s2 = b2*i2, s3 = b3*i3;
+  ca_size_t k;
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*s1;
+        p2 = q2 + k*s2;
+        p3 = q3 + k*s3;
+        { 
+      int cmp = memcmp(p1, p2, b1 < b2 ? b1 : b2);
+      (*p3) = ( cmp < 0 || ( cmp == 0 && b1 <= b2 ) );
+     }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*s1;
+      p2 = q2 + k*s2;
+      p3 = q3 + k*s3;
+      { 
+      int cmp = memcmp(p1, p2, b1 < b2 ? b1 : b2);
+      (*p3) = ( cmp < 0 || ( cmp == 0 && b1 <= b2 ) );
+     }
+    }
+  }
+}
+
+static void
+ca_bincmp_le_boolean8_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  boolean8_t *q1 = (boolean8_t *) ptr1, *q2 = (boolean8_t *) ptr2;
+  boolean8_t *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = ( (*p1) <= (*p2) ); }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = ( (*p1) <= (*p2) ); }
+    }
+  }
+}
+
+static void
+ca_bincmp_le_int8_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  int8_t *q1 = (int8_t *) ptr1, *q2 = (int8_t *) ptr2;
+  int8_t *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = ( (*p1) <= (*p2) ); }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = ( (*p1) <= (*p2) ); }
+    }
+  }
+}
+
+static void
+ca_bincmp_le_uint8_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  uint8_t *q1 = (uint8_t *) ptr1, *q2 = (uint8_t *) ptr2;
+  uint8_t *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = ( (*p1) <= (*p2) ); }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = ( (*p1) <= (*p2) ); }
+    }
+  }
+}
+
+static void
+ca_bincmp_le_int16_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  int16_t *q1 = (int16_t *) ptr1, *q2 = (int16_t *) ptr2;
+  int16_t *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = ( (*p1) <= (*p2) ); }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = ( (*p1) <= (*p2) ); }
+    }
+  }
+}
+
+static void
+ca_bincmp_le_uint16_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  uint16_t *q1 = (uint16_t *) ptr1, *q2 = (uint16_t *) ptr2;
+  uint16_t *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = ( (*p1) <= (*p2) ); }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = ( (*p1) <= (*p2) ); }
+    }
+  }
+}
+
+static void
+ca_bincmp_le_int32_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  int32_t *q1 = (int32_t *) ptr1, *q2 = (int32_t *) ptr2;
+  int32_t *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = ( (*p1) <= (*p2) ); }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = ( (*p1) <= (*p2) ); }
+    }
+  }
+}
+
+static void
+ca_bincmp_le_uint32_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  uint32_t *q1 = (uint32_t *) ptr1, *q2 = (uint32_t *) ptr2;
+  uint32_t *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = ( (*p1) <= (*p2) ); }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = ( (*p1) <= (*p2) ); }
+    }
+  }
+}
+
+static void
+ca_bincmp_le_int64_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  int64_t *q1 = (int64_t *) ptr1, *q2 = (int64_t *) ptr2;
+  int64_t *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = ( (*p1) <= (*p2) ); }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = ( (*p1) <= (*p2) ); }
+    }
+  }
+}
+
+static void
+ca_bincmp_le_uint64_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  uint64_t *q1 = (uint64_t *) ptr1, *q2 = (uint64_t *) ptr2;
+  uint64_t *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = ( (*p1) <= (*p2) ); }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = ( (*p1) <= (*p2) ); }
+    }
+  }
+}
+
+static void
+ca_bincmp_le_float32_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  float *q1 = (float *) ptr1, *q2 = (float *) ptr2;
+  float *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = ( (*p1) <= (*p2) ); }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = ( (*p1) <= (*p2) ); }
+    }
+  }
+}
+
+static void
+ca_bincmp_le_float64_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  double *q1 = (double *) ptr1, *q2 = (double *) ptr2;
+  double *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = ( (*p1) <= (*p2) ); }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = ( (*p1) <= (*p2) ); }
+    }
+  }
+}
+
+static void
+ca_bincmp_le_VALUE (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  VALUE *q1 = (VALUE *) ptr1, *q2 = (VALUE *) ptr2;
+  VALUE *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = RTEST(rb_funcall((*p1), rb_intern("<="), 1, (*p2))) ? 1 : 0; }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = RTEST(rb_funcall((*p1), rb_intern("<="), 1, (*p2))) ? 1 : 0; }
+    }
+  }
+}
+
+ca_bincmp_func_t
+ca_bincmp_le[CA_NTYPE] = {
+  ca_bincmp_le_fixlen,
+  ca_bincmp_le_boolean8_t,
+  ca_bincmp_le_int8_t,
+  ca_bincmp_le_uint8_t,
+  ca_bincmp_le_int16_t,
+  ca_bincmp_le_uint16_t,
+  ca_bincmp_le_int32_t,
+  ca_bincmp_le_uint32_t,
+  ca_bincmp_le_int64_t,
+  ca_bincmp_le_uint64_t,
+  ca_bincmp_le_float32_t,
+  ca_bincmp_le_float64_t,
+  ca_bincmp_not_implement,
+  ca_bincmp_not_implement,
+  ca_bincmp_not_implement,
+  ca_bincmp_not_implement,
+  ca_bincmp_le_VALUE,
+};
+
+VALUE rb_ca_le (VALUE self, VALUE other)
+{
+  if ( ! rb_ca_test_castable(other) ) {
+    return rb_ca_binop_pass_to_other(self, other, rb_intern("le"));
+  }
+  return rb_ca_call_bincmp(self, other, ca_bincmp_le, 0.0);
+}
+
+/* ===== bincmp match ============================================ */
+
+static void
+ca_bincmp_match_fixlen (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  char *q1 = ptr1, *q2 = ptr2;
+  char *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t s1 = b1*i1, s2 = b2*i2, s3 = b3*i3;
+  ca_size_t k;
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*s1;
+        p2 = q2 + k*s2;
+        p3 = q3 + k*s3;
+        { 
+      (*p3) = RTEST(rb_funcall(rb_str_new(p1,b1), rb_intern("=~"), 1, (*p2)));
+     }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*s1;
+      p2 = q2 + k*s2;
+      p3 = q3 + k*s3;
+      { 
+      (*p3) = RTEST(rb_funcall(rb_str_new(p1,b1), rb_intern("=~"), 1, (*p2)));
+     }
+    }
+  }
+}
+
+static void
+ca_bincmp_match_VALUE (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  VALUE *q1 = (VALUE *) ptr1, *q2 = (VALUE *) ptr2;
+  VALUE *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = RTEST(rb_funcall((*p1), rb_intern("=~"), 1, (*p2))); }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = RTEST(rb_funcall((*p1), rb_intern("=~"), 1, (*p2))); }
+    }
+  }
+}
+
+ca_bincmp_func_t
+ca_bincmp_match[CA_NTYPE] = {
+  ca_bincmp_match_fixlen,
+  ca_bincmp_not_implement,
+  ca_bincmp_not_implement,
+  ca_bincmp_not_implement,
+  ca_bincmp_not_implement,
+  ca_bincmp_not_implement,
+  ca_bincmp_not_implement,
+  ca_bincmp_not_implement,
+  ca_bincmp_not_implement,
+  ca_bincmp_not_implement,
+  ca_bincmp_not_implement,
+  ca_bincmp_not_implement,
+  ca_bincmp_not_implement,
+  ca_bincmp_not_implement,
+  ca_bincmp_not_implement,
+  ca_bincmp_not_implement,
+  ca_bincmp_match_VALUE,
+};
+
+VALUE rb_ca_match (VALUE self, VALUE other)
+{
+  if ( ! rb_ca_test_castable(other) ) {
+    return rb_ca_binop_pass_to_other(self, other, rb_intern("match"));
+  }
+  return rb_ca_call_bincmp(self, other, ca_bincmp_match, 0.0);
+}
+
+/* ===== bincmp is_kind_of ============================================ */
+
+static void
+ca_bincmp_is_kind_of_VALUE (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  VALUE *q1 = (VALUE *) ptr1, *q2 = (VALUE *) ptr2;
+  VALUE *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+  (void) tol;
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = RTEST(rb_obj_is_kind_of((*p1), (*p2))); }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = RTEST(rb_obj_is_kind_of((*p1), (*p2))); }
+    }
+  }
+}
+
+ca_bincmp_func_t
+ca_bincmp_is_kind_of[CA_NTYPE] = {
+  ca_bincmp_not_implement,
+  ca_bincmp_not_implement,
+  ca_bincmp_not_implement,
+  ca_bincmp_not_implement,
+  ca_bincmp_not_implement,
+  ca_bincmp_not_implement,
+  ca_bincmp_not_implement,
+  ca_bincmp_not_implement,
+  ca_bincmp_not_implement,
+  ca_bincmp_not_implement,
+  ca_bincmp_not_implement,
+  ca_bincmp_not_implement,
+  ca_bincmp_not_implement,
+  ca_bincmp_not_implement,
+  ca_bincmp_not_implement,
+  ca_bincmp_not_implement,
+  ca_bincmp_is_kind_of_VALUE,
+};
+
+VALUE rb_ca_is_kind_of (VALUE self, VALUE other)
+{
+  if ( ! rb_ca_test_castable(other) ) {
+    return rb_ca_binop_pass_to_other(self, other, rb_intern("is_kind_of"));
+  }
+  return rb_ca_call_bincmp(self, other, ca_bincmp_is_kind_of, 0.0);
+}
+
+/* ===== bincmp is_close ============================================ */
+
+static void
+ca_bincmp_is_close_int8_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  int8_t *q1 = (int8_t *) ptr1, *q2 = (int8_t *) ptr2;
+  int8_t *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+ 
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = (fabs((double)(*p1) - (double)(*p2)) <= tol) ? 1 : 0; }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = (fabs((double)(*p1) - (double)(*p2)) <= tol) ? 1 : 0; }
+    }
+  }
+}
+
+static void
+ca_bincmp_is_close_uint8_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  uint8_t *q1 = (uint8_t *) ptr1, *q2 = (uint8_t *) ptr2;
+  uint8_t *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+ 
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = (fabs((double)(*p1) - (double)(*p2)) <= tol) ? 1 : 0; }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = (fabs((double)(*p1) - (double)(*p2)) <= tol) ? 1 : 0; }
+    }
+  }
+}
+
+static void
+ca_bincmp_is_close_int16_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  int16_t *q1 = (int16_t *) ptr1, *q2 = (int16_t *) ptr2;
+  int16_t *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+ 
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = (fabs((double)(*p1) - (double)(*p2)) <= tol) ? 1 : 0; }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = (fabs((double)(*p1) - (double)(*p2)) <= tol) ? 1 : 0; }
+    }
+  }
+}
+
+static void
+ca_bincmp_is_close_uint16_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  uint16_t *q1 = (uint16_t *) ptr1, *q2 = (uint16_t *) ptr2;
+  uint16_t *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+ 
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = (fabs((double)(*p1) - (double)(*p2)) <= tol) ? 1 : 0; }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = (fabs((double)(*p1) - (double)(*p2)) <= tol) ? 1 : 0; }
+    }
+  }
+}
+
+static void
+ca_bincmp_is_close_int32_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  int32_t *q1 = (int32_t *) ptr1, *q2 = (int32_t *) ptr2;
+  int32_t *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+ 
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = (fabs((double)(*p1) - (double)(*p2)) <= tol) ? 1 : 0; }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = (fabs((double)(*p1) - (double)(*p2)) <= tol) ? 1 : 0; }
+    }
+  }
+}
+
+static void
+ca_bincmp_is_close_uint32_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  uint32_t *q1 = (uint32_t *) ptr1, *q2 = (uint32_t *) ptr2;
+  uint32_t *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+ 
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = (fabs((double)(*p1) - (double)(*p2)) <= tol) ? 1 : 0; }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = (fabs((double)(*p1) - (double)(*p2)) <= tol) ? 1 : 0; }
+    }
+  }
+}
+
+static void
+ca_bincmp_is_close_int64_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  int64_t *q1 = (int64_t *) ptr1, *q2 = (int64_t *) ptr2;
+  int64_t *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+ 
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = (fabs((double)(*p1) - (double)(*p2)) <= tol) ? 1 : 0; }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = (fabs((double)(*p1) - (double)(*p2)) <= tol) ? 1 : 0; }
+    }
+  }
+}
+
+static void
+ca_bincmp_is_close_uint64_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  uint64_t *q1 = (uint64_t *) ptr1, *q2 = (uint64_t *) ptr2;
+  uint64_t *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+ 
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = (fabs((double)(*p1) - (double)(*p2)) <= tol) ? 1 : 0; }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = (fabs((double)(*p1) - (double)(*p2)) <= tol) ? 1 : 0; }
+    }
+  }
+}
+
+static void
+ca_bincmp_is_close_float32_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  float *q1 = (float *) ptr1, *q2 = (float *) ptr2;
+  float *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+ 
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = (fabs((*p1) - (*p2)) <= tol) ? 1 : 0; }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = (fabs((*p1) - (*p2)) <= tol) ? 1 : 0; }
+    }
+  }
+}
+
+static void
+ca_bincmp_is_close_float64_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  double *q1 = (double *) ptr1, *q2 = (double *) ptr2;
+  double *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+ 
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = (fabs((*p1) - (*p2)) <= tol) ? 1 : 0; }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = (fabs((*p1) - (*p2)) <= tol) ? 1 : 0; }
+    }
+  }
+}
+
+static void
+ca_bincmp_is_close_cmplx64_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  cmplx64_t *q1 = (cmplx64_t *) ptr1, *q2 = (cmplx64_t *) ptr2;
+  cmplx64_t *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+ 
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = (cabs((*p1) - (*p2)) <= tol) ? 1 : 0; }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = (cabs((*p1) - (*p2)) <= tol) ? 1 : 0; }
+    }
+  }
+}
+
+static void
+ca_bincmp_is_close_cmplx128_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  cmplx128_t *q1 = (cmplx128_t *) ptr1, *q2 = (cmplx128_t *) ptr2;
+  cmplx128_t *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+ 
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { (*p3) = (cabs((*p1) - (*p2)) <= tol) ? 1 : 0; }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { (*p3) = (cabs((*p1) - (*p2)) <= tol) ? 1 : 0; }
+    }
+  }
+}
+
+ca_bincmp_func_t
+ca_bincmp_is_close[CA_NTYPE] = {
+  ca_bincmp_not_implement,
+  ca_bincmp_not_implement,
+  ca_bincmp_is_close_int8_t,
+  ca_bincmp_is_close_uint8_t,
+  ca_bincmp_is_close_int16_t,
+  ca_bincmp_is_close_uint16_t,
+  ca_bincmp_is_close_int32_t,
+  ca_bincmp_is_close_uint32_t,
+  ca_bincmp_is_close_int64_t,
+  ca_bincmp_is_close_uint64_t,
+  ca_bincmp_is_close_float32_t,
+  ca_bincmp_is_close_float64_t,
+  ca_bincmp_not_implement,
+  ca_bincmp_is_close_cmplx64_t,
+  ca_bincmp_is_close_cmplx128_t,
+  ca_bincmp_not_implement,
+  ca_bincmp_not_implement,
+};
+
+VALUE rb_ca_is_close (VALUE self, VALUE other, VALUE tol_val)
+{
+  double tol = fabs(NUM2DBL(tol_val));
+  if ( ! rb_ca_test_castable(other) ) {
+    return rb_funcall(other, rb_intern("is_close"), 2, self, tol_val);
+  }
+  return rb_ca_call_bincmp(self, other, ca_bincmp_is_close, tol);
+}
+
+/* ===== bincmp is_equiv ============================================ */
+
+static void
+ca_bincmp_is_equiv_int8_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  int8_t *q1 = (int8_t *) ptr1, *q2 = (int8_t *) ptr2;
+  int8_t *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+ 
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { 
+      double a = (double)(*p1), b = (double)(*p2);
+      double aa = fabs(a), ab = fabs(b);
+      double m = (aa > ab) ? aa : ab;
+      (*p3) = ( (*p1) == (*p2) || (m > 0 && fabs(a - b) / m <= tol) ) ? 1 : 0;
+     }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { 
+      double a = (double)(*p1), b = (double)(*p2);
+      double aa = fabs(a), ab = fabs(b);
+      double m = (aa > ab) ? aa : ab;
+      (*p3) = ( (*p1) == (*p2) || (m > 0 && fabs(a - b) / m <= tol) ) ? 1 : 0;
+     }
+    }
+  }
+}
+
+static void
+ca_bincmp_is_equiv_uint8_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  uint8_t *q1 = (uint8_t *) ptr1, *q2 = (uint8_t *) ptr2;
+  uint8_t *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+ 
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { 
+      double a = (double)(*p1), b = (double)(*p2);
+      double aa = fabs(a), ab = fabs(b);
+      double m = (aa > ab) ? aa : ab;
+      (*p3) = ( (*p1) == (*p2) || (m > 0 && fabs(a - b) / m <= tol) ) ? 1 : 0;
+     }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { 
+      double a = (double)(*p1), b = (double)(*p2);
+      double aa = fabs(a), ab = fabs(b);
+      double m = (aa > ab) ? aa : ab;
+      (*p3) = ( (*p1) == (*p2) || (m > 0 && fabs(a - b) / m <= tol) ) ? 1 : 0;
+     }
+    }
+  }
+}
+
+static void
+ca_bincmp_is_equiv_int16_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  int16_t *q1 = (int16_t *) ptr1, *q2 = (int16_t *) ptr2;
+  int16_t *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+ 
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { 
+      double a = (double)(*p1), b = (double)(*p2);
+      double aa = fabs(a), ab = fabs(b);
+      double m = (aa > ab) ? aa : ab;
+      (*p3) = ( (*p1) == (*p2) || (m > 0 && fabs(a - b) / m <= tol) ) ? 1 : 0;
+     }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { 
+      double a = (double)(*p1), b = (double)(*p2);
+      double aa = fabs(a), ab = fabs(b);
+      double m = (aa > ab) ? aa : ab;
+      (*p3) = ( (*p1) == (*p2) || (m > 0 && fabs(a - b) / m <= tol) ) ? 1 : 0;
+     }
+    }
+  }
+}
+
+static void
+ca_bincmp_is_equiv_uint16_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  uint16_t *q1 = (uint16_t *) ptr1, *q2 = (uint16_t *) ptr2;
+  uint16_t *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+ 
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { 
+      double a = (double)(*p1), b = (double)(*p2);
+      double aa = fabs(a), ab = fabs(b);
+      double m = (aa > ab) ? aa : ab;
+      (*p3) = ( (*p1) == (*p2) || (m > 0 && fabs(a - b) / m <= tol) ) ? 1 : 0;
+     }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { 
+      double a = (double)(*p1), b = (double)(*p2);
+      double aa = fabs(a), ab = fabs(b);
+      double m = (aa > ab) ? aa : ab;
+      (*p3) = ( (*p1) == (*p2) || (m > 0 && fabs(a - b) / m <= tol) ) ? 1 : 0;
+     }
+    }
+  }
+}
+
+static void
+ca_bincmp_is_equiv_int32_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  int32_t *q1 = (int32_t *) ptr1, *q2 = (int32_t *) ptr2;
+  int32_t *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+ 
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { 
+      double a = (double)(*p1), b = (double)(*p2);
+      double aa = fabs(a), ab = fabs(b);
+      double m = (aa > ab) ? aa : ab;
+      (*p3) = ( (*p1) == (*p2) || (m > 0 && fabs(a - b) / m <= tol) ) ? 1 : 0;
+     }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { 
+      double a = (double)(*p1), b = (double)(*p2);
+      double aa = fabs(a), ab = fabs(b);
+      double m = (aa > ab) ? aa : ab;
+      (*p3) = ( (*p1) == (*p2) || (m > 0 && fabs(a - b) / m <= tol) ) ? 1 : 0;
+     }
+    }
+  }
+}
+
+static void
+ca_bincmp_is_equiv_uint32_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  uint32_t *q1 = (uint32_t *) ptr1, *q2 = (uint32_t *) ptr2;
+  uint32_t *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+ 
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { 
+      double a = (double)(*p1), b = (double)(*p2);
+      double aa = fabs(a), ab = fabs(b);
+      double m = (aa > ab) ? aa : ab;
+      (*p3) = ( (*p1) == (*p2) || (m > 0 && fabs(a - b) / m <= tol) ) ? 1 : 0;
+     }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { 
+      double a = (double)(*p1), b = (double)(*p2);
+      double aa = fabs(a), ab = fabs(b);
+      double m = (aa > ab) ? aa : ab;
+      (*p3) = ( (*p1) == (*p2) || (m > 0 && fabs(a - b) / m <= tol) ) ? 1 : 0;
+     }
+    }
+  }
+}
+
+static void
+ca_bincmp_is_equiv_int64_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  int64_t *q1 = (int64_t *) ptr1, *q2 = (int64_t *) ptr2;
+  int64_t *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+ 
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { 
+      double a = (double)(*p1), b = (double)(*p2);
+      double aa = fabs(a), ab = fabs(b);
+      double m = (aa > ab) ? aa : ab;
+      (*p3) = ( (*p1) == (*p2) || (m > 0 && fabs(a - b) / m <= tol) ) ? 1 : 0;
+     }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { 
+      double a = (double)(*p1), b = (double)(*p2);
+      double aa = fabs(a), ab = fabs(b);
+      double m = (aa > ab) ? aa : ab;
+      (*p3) = ( (*p1) == (*p2) || (m > 0 && fabs(a - b) / m <= tol) ) ? 1 : 0;
+     }
+    }
+  }
+}
+
+static void
+ca_bincmp_is_equiv_uint64_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  uint64_t *q1 = (uint64_t *) ptr1, *q2 = (uint64_t *) ptr2;
+  uint64_t *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+ 
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { 
+      double a = (double)(*p1), b = (double)(*p2);
+      double aa = fabs(a), ab = fabs(b);
+      double m = (aa > ab) ? aa : ab;
+      (*p3) = ( (*p1) == (*p2) || (m > 0 && fabs(a - b) / m <= tol) ) ? 1 : 0;
+     }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { 
+      double a = (double)(*p1), b = (double)(*p2);
+      double aa = fabs(a), ab = fabs(b);
+      double m = (aa > ab) ? aa : ab;
+      (*p3) = ( (*p1) == (*p2) || (m > 0 && fabs(a - b) / m <= tol) ) ? 1 : 0;
+     }
+    }
+  }
+}
+
+static void
+ca_bincmp_is_equiv_float32_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  float *q1 = (float *) ptr1, *q2 = (float *) ptr2;
+  float *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+ 
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { 
+      float aa = fabs((*p1)), ab = fabs((*p2));
+      float m = (aa > ab) ? aa : ab;
+      (*p3) = ( (*p1) == (*p2) || (m > 0 && fabs((*p1) - (*p2)) / m <= tol) ) ? 1 : 0;
+     }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { 
+      float aa = fabs((*p1)), ab = fabs((*p2));
+      float m = (aa > ab) ? aa : ab;
+      (*p3) = ( (*p1) == (*p2) || (m > 0 && fabs((*p1) - (*p2)) / m <= tol) ) ? 1 : 0;
+     }
+    }
+  }
+}
+
+static void
+ca_bincmp_is_equiv_float64_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  double *q1 = (double *) ptr1, *q2 = (double *) ptr2;
+  double *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+ 
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { 
+      double aa = fabs((*p1)), ab = fabs((*p2));
+      double m = (aa > ab) ? aa : ab;
+      (*p3) = ( (*p1) == (*p2) || (m > 0 && fabs((*p1) - (*p2)) / m <= tol) ) ? 1 : 0;
+     }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { 
+      double aa = fabs((*p1)), ab = fabs((*p2));
+      double m = (aa > ab) ? aa : ab;
+      (*p3) = ( (*p1) == (*p2) || (m > 0 && fabs((*p1) - (*p2)) / m <= tol) ) ? 1 : 0;
+     }
+    }
+  }
+}
+
+static void
+ca_bincmp_is_equiv_cmplx64_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  cmplx64_t *q1 = (cmplx64_t *) ptr1, *q2 = (cmplx64_t *) ptr2;
+  cmplx64_t *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+ 
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { 
+      double aa = cabs((*p1)), ab = cabs((*p2));
+      double m = (aa > ab) ? aa : ab;
+      (*p3) = ( m > 0 && cabs((*p1) - (*p2)) / m <= tol ) ? 1 : 0;
+     }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { 
+      double aa = cabs((*p1)), ab = cabs((*p2));
+      double m = (aa > ab) ? aa : ab;
+      (*p3) = ( m > 0 && cabs((*p1) - (*p2)) / m <= tol ) ? 1 : 0;
+     }
+    }
+  }
+}
+
+static void
+ca_bincmp_is_equiv_cmplx128_t (ca_size_t n, boolean8_t *m,
+                                  char *ptr1, ca_size_t b1, ca_size_t i1,
+                                  char *ptr2, ca_size_t b2, ca_size_t i2,
+                                  char *ptr3, ca_size_t b3, ca_size_t i3,
+                                  double tol)
+{
+  cmplx128_t *q1 = (cmplx128_t *) ptr1, *q2 = (cmplx128_t *) ptr2;
+  cmplx128_t *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  ca_size_t k;
+  (void) b1; (void) b2; (void) b3;  /* unused for non-fixlen kernels */
+ 
+  if ( m ) {
+    boolean8_t *pm;
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        { 
+      double aa = cabs((*p1)), ab = cabs((*p2));
+      double m = (aa > ab) ? aa : ab;
+      (*p3) = ( m > 0 && cabs((*p1) - (*p2)) / m <= tol ) ? 1 : 0;
+     }
+      }
+    }
+  } else {
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      { 
+      double aa = cabs((*p1)), ab = cabs((*p2));
+      double m = (aa > ab) ? aa : ab;
+      (*p3) = ( m > 0 && cabs((*p1) - (*p2)) / m <= tol ) ? 1 : 0;
+     }
+    }
+  }
+}
+
+ca_bincmp_func_t
+ca_bincmp_is_equiv[CA_NTYPE] = {
+  ca_bincmp_not_implement,
+  ca_bincmp_not_implement,
+  ca_bincmp_is_equiv_int8_t,
+  ca_bincmp_is_equiv_uint8_t,
+  ca_bincmp_is_equiv_int16_t,
+  ca_bincmp_is_equiv_uint16_t,
+  ca_bincmp_is_equiv_int32_t,
+  ca_bincmp_is_equiv_uint32_t,
+  ca_bincmp_is_equiv_int64_t,
+  ca_bincmp_is_equiv_uint64_t,
+  ca_bincmp_is_equiv_float32_t,
+  ca_bincmp_is_equiv_float64_t,
+  ca_bincmp_not_implement,
+  ca_bincmp_is_equiv_cmplx64_t,
+  ca_bincmp_is_equiv_cmplx128_t,
+  ca_bincmp_not_implement,
+  ca_bincmp_not_implement,
+};
+
+VALUE rb_ca_is_equiv (VALUE self, VALUE other, VALUE tol_val)
+{
+  double tol = fabs(NUM2DBL(tol_val));
+  if ( ! rb_ca_test_castable(other) ) {
+    return rb_funcall(other, rb_intern("is_equiv"), 2, self, tol_val);
+  }
+  return rb_ca_call_bincmp(self, other, ca_bincmp_is_equiv, tol);
+}
+
+void
+Init_carray_kernels_bincmp (void)
+{
+  rb_define_method(rb_cCArray, "feq", rb_ca_feq, 1);
+  rb_define_method(rb_cCArray, "eq", rb_ca_eq, 1);
+  rb_define_method(rb_cCArray, "ne", rb_ca_ne, 1);
+  rb_define_method(rb_cCArray, "gt", rb_ca_gt, 1);
+  rb_define_method(rb_cCArray, "lt", rb_ca_lt, 1);
+  rb_define_method(rb_cCArray, "ge", rb_ca_ge, 1);
+  rb_define_method(rb_cCArray, "le", rb_ca_le, 1);
+  rb_define_method(rb_cCArray, "match", rb_ca_match, 1);
+  rb_define_method(rb_cCArray, "is_kind_of", rb_ca_is_kind_of, 1);
+  rb_define_alias(rb_cCArray, ">", "gt");
+  rb_define_alias(rb_cCArray, "<", "lt");
+  rb_define_alias(rb_cCArray, ">=", "ge");
+  rb_define_alias(rb_cCArray, "<=", "le");
+  rb_define_alias(rb_cCArray, "=~", "match");
+  rb_define_method(rb_cCArray, "is_close", rb_ca_is_close, 2);
+  rb_define_method(rb_cCArray, "is_equiv", rb_ca_is_equiv, 2);
+}