klongpy 0.7.0__py3-none-any.whl → 0.7.1__py3-none-any.whl

klongpy/dyads.py

@@ -1,14 +1,9 @@
 from .core import *
 from .autograd import grad_of_fn, numeric_grad, jacobian_of_fn, multi_jacobian_of_fn, multi_grad_of_fn
-from .backend import (
-    to_numpy, safe_equal, detach_if_needed, to_int_array, power as backend_power, has_gradient,
-    kg_asarray, str_to_chr_arr, kg_equal, is_integer, is_float, get_dtype_kind, array_size
-)
-import sys
 import numpy
 
 
-def eval_dyad_add(a, b):
+def eval_dyad_add(a, b, backend):
     """
 
         a+b                                                       [Plus]
@@ -23,10 +18,10 @@ def eval_dyad_add(a, b):
                   1+0.3  -->  1.3
 
     """
-    return np.add(a, b)
+    return backend.np.add(a, b)
 
 
-def eval_dyad_amend(a, b):
+def eval_dyad_amend(a, b, backend):
     """
 
         a:=b                                                     [Amend]
@@ -52,13 +47,14 @@ def eval_dyad_amend(a, b):
                          "abc":="def",3  -->  "abcdef"
 
     """
-    if not (isinstance(a, (str,list)) or np.isarray(a)):
+    np_backend = backend.np
+    if not (isinstance(a, (str,list)) or np_backend.isarray(a)):
         raise RuntimeError(f"a must be list or str: {a}")
     if len(b) <= 1:
         return a
     if isinstance(a, str):
-        r = str_to_chr_arr(a)
-        q = str_to_chr_arr(b[0])
+        r = backend.str_to_chr_arr(a)
+        q = backend.str_to_chr_arr(b[0])
         for i in b[1:]:
             try:
                 r[i:i+len(q)] = q
@@ -67,29 +63,29 @@ def eval_dyad_amend(a, b):
                 if i > len(r):
                     RangeError(i)
                 elif i == len(r):
-                    r = np.append(r, b[0])
+                    r = numpy.append(r, b[0])
                 else:
                     r[i] = b[0]
         return "".join(["".join(x) for x in r])
-    r = np.array(a) # clone
-    if is_list(b[0]): # TOOD: use np.put if we can
+    r = np_backend.array(a) # clone
+    if is_list(b[0]): # TOOD: use bknp.put if we can
         r = r.tolist()
         for i in b[1:]:
             r[i] = b[0]
-        r = kg_asarray(r)
+        r = backend.kg_asarray(r)
     else:
-        np.put(r, np.asarray(b[1:],dtype=int), b[0])
+        numpy.put(r, numpy.asarray(b[1:],dtype=int), b[0])
     return r
 
 
 def _e_dyad_amend_in_depth(p, q, v):
-    if np.isarray(q) and len(q) > 1:
+    if bknp.isarray(q) and len(q) > 1:
         r = _e_dyad_amend_in_depth(p[q[0]], q[1:] if len(q) > 2 else q[1], v)
-        p = np.array(p, dtype=r.dtype)
+        p = bknp.array(p, dtype=r.dtype)
         p[q[0]] = r
         return p
     else:
-        p = np.array(p, dtype=object) if isinstance(v, (str, KGSym)) else np.array(p)
+        p = bknp.array(p, dtype=object) if isinstance(v, (str, KGSym)) else bknp.array(p)
         p[q] = v
         return p
 
@@ -111,7 +107,7 @@ def eval_dyad_amend_in_depth(a, b):
     return _e_dyad_amend_in_depth(a, b[1:], b[0])
 
 
-def eval_dyad_cut(a, b):
+def eval_dyad_cut(a, b, backend):
     """
 
         a:_b                                                       [Cut]
@@ -133,12 +129,12 @@ def eval_dyad_cut(a, b):
 
     """
     j = isinstance(b, str)
-    b = np.asarray(str_to_chr_arr(b) if j else b)
-    a = a if np.isarray(a) else [a]
-    r = np.array_split(b, a)
+    b = bknp.asarray(backend.str_to_chr_arr(b) if j else b)
+    a = a if bknp.isarray(a) else [a]
+    r = bknp.array_split(b, a)
     if len(b) == 0 and len(a) > 0:
         r = r[1:]
-    return np.asarray(["".join(x) for x in r]) if j else kg_asarray(r)
+    return bknp.asarray(["".join(x) for x in r]) if j else backend.kg_asarray(r)
 
 
 def eval_dyad_at_index(klong, a, b):
@@ -172,24 +168,25 @@ def eval_dyad_at_index(klong, a, b):
 
     """
     if isinstance(a, (KGFn, KGSym)) or issubclass(type(a), KGLambda):
-        b = [x for x in b] if np.isarray(b) else b
+        b = [x for x in b] if klong._backend.is_array(b) else b
         return klong.eval(KGCall(a, b, arity=1))
+    backend = klong._backend
     j = isinstance(a,str)
-    a = str_to_chr_arr(a) if j else a
+    a = backend.str_to_chr_arr(a) if j else a
     if is_list(b):
         if is_empty(b):
-            r = np.asarray([])
+            r = bknp.asarray([])
         else:
             # TODO: return None for missing keys? or raise?
-            r = kg_asarray([a[x] for x in b])
-    elif is_integer(b):
+            r = backend.kg_asarray([a[x] for x in b])
+    elif backend.is_integer(b):
         r = a[b]
         j = False
     else:
         r = a
     if j:
-        if np.isarray(r) and r.ndim > 1:
-            return np.asarray(["".join(x) for x in r], dtype=object)
+        if bknp.isarray(r) and r.ndim > 1:
+            return bknp.asarray(["".join(x) for x in r], dtype=object)
         return "".join(r)
     return r
 
@@ -214,7 +211,7 @@ def eval_dyad_define(klong, n, v):
     return v
 
 
-def eval_dyad_divide(a, b):
+def eval_dyad_divide(a, b, backend):
     """
 
         a%b                                                     [Divide]
@@ -228,7 +225,11 @@ def eval_dyad_divide(a, b):
                   10%8  -->  1.25
 
     """
-    return np.divide(a, b)
+    if not is_list(a) and not is_list(b) and backend.is_number(b):
+        b_val = backend.scalar_to_python(b) if backend.is_backend_array(b) or (hasattr(b, 'ndim') and b.ndim == 0) else b
+        if b_val == 0:
+            return KLONG_UNDEFINED
+    return backend.np.divide(a, b)
 
 
 def eval_dyad_drop(a, b):
@@ -260,12 +261,12 @@ def eval_dyad_drop(a, b):
     return b[a:] if a >= 0 else b[:a]
 
 
-def _safe_equal(x, y):
-    """Compare two values, handling torch tensors correctly."""
-    return kg_truth(safe_equal(x, y))
+def _safe_equal(x, y, backend):
+    """Compare two values, handling backend arrays correctly."""
+    return kg_truth(backend.safe_equal(x, y))
 
 
-def eval_dyad_equal(a, b):
+def eval_dyad_equal(a, b, backend):
     """
 
         a=b                                                      [Equal]
@@ -290,7 +291,7 @@ def eval_dyad_equal(a, b):
                   [1 2 3]=[1 4 3]  -->  [1 0 1]
 
     """
-    return vec_fn2(a, b, _safe_equal)
+    return backend.vec_fn2(a, b, lambda x, y: _safe_equal(x, y, backend))
 
 
 def finditer(s, sub):
@@ -303,7 +304,7 @@ def finditer(s, sub):
         i += 1
 
 
-def eval_dyad_find(a, b):
+def eval_dyad_find(a, b, backend):
     """
 
         a?b                                                       [Find]
@@ -332,44 +333,44 @@ def eval_dyad_find(a, b):
 
     """
     if isinstance(a,str):
-        return np.asarray(list(finditer(a,str(b))))
+        return bknp.asarray(list(finditer(a,str(b))))
     elif is_dict(a):
         v = a.get(b)
-        return np.inf if v is None else v
+        return KLONG_UNDEFINED if v is None else v
     if is_list(b):
-        return np.asarray([i for i,x in enumerate(a) if kg_equal(x,b)])
-    return np.where(np.asarray(a) == b)[0]
+        return bknp.asarray([i for i,x in enumerate(a) if backend.kg_equal(x, b)])
+    return bknp.where(bknp.asarray(a) == b)[0]
 
 
-def __e_dyad_form(a, b):
+def __e_dyad_form(a, b, backend):
     if isinstance(a,KGSym):
         if is_empty(b):
-            return np.inf
+            return KLONG_UNDEFINED
         return KGSym(b[1:] if isinstance(b,str) and b.startswith(":") else b)
-    if is_integer(a):
-        if is_float(b) or is_empty(b) or ('.' in b and str_is_float(b)):
-            return np.inf
+    if backend.is_integer(a):
+        if backend.is_float(b) or is_empty(b) or ('.' in b and str_is_float(b)):
+            return KLONG_UNDEFINED
         return int(b)
-    if is_float(a):
+    if backend.is_float(a):
         if is_empty(b):
-            return np.inf
+            return KLONG_UNDEFINED
         return float(b)
     if isinstance(a,KGChar):
         b = str(b)
         if len(b) != 1:
-            return np.inf
+            return KLONG_UNDEFINED
         return KGChar(str(b)[0])
     return b
 
-def _e_dyad_form(a, b):
+def _e_dyad_form(a, b, backend):
     """
     Unravel the broadcasting of a and b and apply __e_dyad_form
     """
-    if np.isarray(a) and np.isarray(b):
-        return np.asarray([vec_fn2(x,y,_e_dyad_form) for x,y in zip(a,b)])
-    return __e_dyad_form(a,b)
+    if bknp.isarray(a) and bknp.isarray(b):
+        return bknp.asarray([backend.vec_fn2(x, y, lambda x, y: _e_dyad_form(x, y, backend)) for x,y in zip(a,b)])
+    return __e_dyad_form(a, b, backend)
 
-def eval_dyad_form(a, b):
+def eval_dyad_form(a, b, backend):
     """
 
         a:$b                                                      [Form]
@@ -396,13 +397,17 @@ def eval_dyad_form(a, b):
                   :x:$":symbol"  -->  :symbol
 
     """
-    return vec_fn2(a, b, _e_dyad_form)
+    return backend.vec_fn2(a, b, lambda x, y: _e_dyad_form(x, y, backend))
 
 
-def __e_dyad_format2(a, b):
+def __e_dyad_format2(a, b, backend):
+    if hasattr(a, 'ndim') and a.ndim == 0:
+        a = a.item()
+    if hasattr(b, 'ndim') and b.ndim == 0:
+        b = b.item()
     if safe_eq(int(a), 0):
         return str(b)
-    if (is_float(b) and not isinstance(b,int)) and (is_float(a) and not isinstance(a,int)):
+    if (backend.is_float(b) and not isinstance(b,int)) and (backend.is_float(a) and not isinstance(a,int)):
         b = "{:Xf}".replace("X",str(a)).format(b)
         p = b.split('.')
         p[0] = p[0].rjust(int(a))
@@ -412,17 +417,17 @@ def __e_dyad_format2(a, b):
     r = str(b).ljust(abs(a)) if a >= 0 else str(b).rjust(abs(a))
     return r
 
-def _e_dyad_format2(a, b):
+def _e_dyad_format2(a, b, backend):
     """
     Unravel the broadcasting of a and b and apply __e_dyad_format2
     """
     if is_list(a) and is_list(b):
-        return kg_asarray([vec_fn2(x, y, _e_dyad_format2) for x, y in zip(to_list(a), to_list(b))])
-    if np.isarray(a) and np.isarray(b):
-        return np.asarray([vec_fn2(x, y, _e_dyad_format2) for x, y in zip(a, b)])
-    return __e_dyad_format2(a, b)
+        return backend.kg_asarray([backend.vec_fn2(x, y, lambda x, y: _e_dyad_format2(x, y, backend)) for x, y in zip(to_list(a), to_list(b))])
+    if backend.np.isarray(a) and backend.np.isarray(b):
+        return backend.np.asarray([backend.vec_fn2(x, y, lambda x, y: _e_dyad_format2(x, y, backend)) for x, y in zip(a, b)])
+    return __e_dyad_format2(a, b, backend)
 
-def eval_dyad_format2(a, b):
+def eval_dyad_format2(a, b, backend):
     """
 
         a$b                                                    [Format2]
@@ -447,7 +452,7 @@ def eval_dyad_format2(a, b):
                  5.3$123.45  -->  "  123.450"
 
     """
-    return vec_fn2(a, b, _e_dyad_format2)
+    return backend.vec_fn2(a, b, lambda x, y: _e_dyad_format2(x, y, backend))
 
 
 def eval_dyad_index_in_depth(a, b):
@@ -467,15 +472,16 @@ def eval_dyad_index_in_depth(a, b):
                         {y+x*x}:@[2 3]  -->  7
 
     """
-    return np.asarray(a)[tuple(b) if is_list(b) else b] if not is_empty(b) else b
+    return bknp.asarray(a)[tuple(b) if is_list(b) else b] if not is_empty(b) else b
 
 
-def _e_dyad_integer_divide(x, y):
-    a = np.divide(x, y)
-    a = kg_asarray(rec_fn(a, np.trunc)) if np.isarray(a) else a
-    return to_int_array(a)
+def _e_dyad_integer_divide(x, y, backend):
+    np_backend = backend.np
+    a = np_backend.divide(x, y)
+    a = backend.kg_asarray(backend.rec_fn(a, np_backend.trunc)) if np_backend.isarray(a) else a
+    return backend.to_int_array(a)
 
-def eval_dyad_integer_divide(a, b):
+def eval_dyad_integer_divide(a, b, backend):
     """
 
         a:%b                                            [Integer-Divide]
@@ -491,7 +497,11 @@ def eval_dyad_integer_divide(a, b):
                   10:%8  -->  1
 
     """
-    return vec_fn2(a, b, _e_dyad_integer_divide)
+    if not is_list(a) and not is_list(b) and backend.is_number(b):
+        b_val = backend.scalar_to_python(b) if backend.is_backend_array(b) or (hasattr(b, 'ndim') and b.ndim == 0) else b
+        if b_val == 0:
+            return KLONG_UNDEFINED
+    return backend.vec_fn2(a, b, lambda x, y: _e_dyad_integer_divide(x, y, backend))
 
 
 def _arr_to_list(a):
@@ -499,7 +509,7 @@ def _arr_to_list(a):
     return a if is_list(a) else [a]# if not is_list(a) else a
 
 
-def eval_dyad_join(a, b):
+def eval_dyad_join(a, b, backend):
     """
 
         a,b                                                       [Join]
@@ -550,7 +560,7 @@ def eval_dyad_join(a, b):
         b[a[0]] = a[1]
         return b
 
-    if np.isarray(a) and np.isarray(b):
+    if bknp.isarray(a) and bknp.isarray(b):
         # Only use fast path for 1D+ arrays (not 0D scalars)
         a_is_1d_plus = hasattr(a, 'ndim') and a.ndim >= 1
         b_is_1d_plus = hasattr(b, 'ndim') and b.ndim >= 1
@@ -558,24 +568,24 @@ def eval_dyad_join(a, b):
             if len(a) == 0:
                 return b
             if len(a.shape) == len(b.shape) and a.shape[-1] == b.shape[-1]:
-                return np.concatenate((a,b))
+                return bknp.concatenate((a,b))
 
     aa = _arr_to_list(a)
     bb = _arr_to_list(b)
 
     r = [*aa,*bb]
-    nr = kg_asarray(r)
-    # Check dtype kind for compatibility with both numpy and torch
-    dtype_kind = get_dtype_kind(nr)
+    nr = backend.kg_asarray(r)
+    # Check dtype kind for compatibility across backends
+    dtype_kind = backend.get_dtype_kind(nr)
     if dtype_kind in ('i', 'f', 'u'):
         return nr
-    # Use numpy directly for object arrays (torch backend doesn't support object dtype)
-    # Convert any torch tensors to numpy first (needed for MPS tensors)
-    r_numpy = [to_numpy(x) if np.isarray(x) else x for x in r]
+    # Use numpy directly for object arrays (backends without object dtype need this)
+    # Convert backend arrays to numpy first (needed for device-backed arrays)
+    r_numpy = [backend.to_numpy(x) if backend.is_array(x) else x for x in r]
     return numpy.asarray(r_numpy, dtype=object)
 
 
-def eval_dyad_less(a, b):
+def eval_dyad_less(a, b, backend):
     """
 
         a<b                                                       [Less]
@@ -596,10 +606,10 @@ def eval_dyad_less(a, b):
                    [1 2 3]<[1 4 3]  -->  [0 1 0]
 
     """
-    return kg_truth(vec_fn2(a, b, lambda x,y: x < y if (isinstance(x,str) and isinstance(y,str)) else np.less(x,y)))
+    return kg_truth(backend.vec_fn2(a, b, lambda x,y: x < y if (isinstance(x,str) and isinstance(y,str)) else backend.np.less(x,y)))
 
 
-def eval_dyad_match(a,b):
+def eval_dyad_match(a, b, backend):
     """
 
         a~b                                                      [Match]
@@ -633,10 +643,10 @@ def eval_dyad_match(a,b):
                    [1 [2] 3]~[1 [4] 3]  -->  0
 
     """
-    return kg_truth(kg_equal(a,b))
+    return kg_truth(backend.kg_equal(a, b))
 
 
-def eval_dyad_maximum(a, b):
+def eval_dyad_maximum(a, b, backend):
     """
 
         a|b                                                     [Max/Or]
@@ -660,10 +670,10 @@ def eval_dyad_maximum(a, b):
                     1.0|1.1  -->  1.1
 
     """
-    return np.maximum(a, b)
+    return backend.np.maximum(a, b)
 
 
-def eval_dyad_minimum(a, b):
+def eval_dyad_minimum(a, b, backend):
     """
 
         a&b                                                    [Min/And]
@@ -687,10 +697,10 @@ def eval_dyad_minimum(a, b):
                     1.0&1.1  -->  1.0
 
     """
-    return np.minimum(a, b)
+    return backend.np.minimum(a, b)
 
 
-def eval_dyad_more(a, b):
+def eval_dyad_more(a, b, backend):
     """
 
         a>b                                                       [More]
@@ -709,10 +719,10 @@ def eval_dyad_more(a, b):
                    [1 4 3]>[1 2 3]  -->  [0 1 0]
 
     """
-    return kg_truth(vec_fn2(a, b, lambda x,y: x > y if (isinstance(x,str) and isinstance(y,str)) else np.greater(x,y)))
+    return kg_truth(backend.vec_fn2(a, b, lambda x,y: x > y if (isinstance(x,str) and isinstance(y,str)) else backend.np.greater(x,y)))
 
 
-def eval_dyad_multiply(a, b):
+def eval_dyad_multiply(a, b, backend):
     """
 
         a*b                                                      [Times]
@@ -726,19 +736,19 @@ def eval_dyad_multiply(a, b):
                   0.3*7  -->  2.1
 
     """
-    return np.multiply(a, b)
+    return backend.np.multiply(a, b)
 
 
-def _e_dyad_power(a, b):
+def _e_dyad_power(a, b, backend):
     # Check if input requires grad - if so, preserve float for autograd
-    input_has_grad = has_gradient(a)
-    # Use backend power function which handles torch.pow for gradients
-    r = backend_power(a, b)
+    input_has_grad = backend.has_gradient(a)
+    # Use backend power function which handles gradient-aware power
+    r = backend.power(a, b)
     # If input had gradients, keep result as float to preserve autograd
     if input_has_grad:
         return r
     # Check if result is integer using vectorized operations
-    r_val = detach_if_needed(r)
+    r_val = backend.detach_if_needed(r)
     if is_list(r_val):
         # Vectorized check: trunc(r) == r for all elements
         trunc_r = numpy.trunc(r_val) if isinstance(r_val, numpy.ndarray) else r_val.trunc()
@@ -747,10 +757,10 @@ def _e_dyad_power(a, b):
         val = float(r_val) if hasattr(r_val, 'item') else r_val
         br = numpy.trunc(val) == val
     if br:
-        return to_int_array(r)
+        return backend.to_int_array(r)
     return r
 
-def eval_dyad_power(a, b):
+def eval_dyad_power(a, b, backend):
     """
 
         a^b                                                      [Power]
@@ -769,10 +779,10 @@ def eval_dyad_power(a, b):
                   2^0.5  -->  1.41421356237309504
 
     """
-    return vec_fn2(a, b, _e_dyad_power)
+    return backend.vec_fn2(a, b, lambda x, y: _e_dyad_power(x, y, backend))
 
 
-def eval_dyad_remainder(a, b):
+def eval_dyad_remainder(a, b, backend):
     """
 
         a!b                                                  [Remainder]
@@ -790,10 +800,10 @@ def eval_dyad_remainder(a, b):
                    -7!-5  --> -2
 
     """
-    return np.fmod(a, b)
+    return backend.np.fmod(a, b)
 
 
-def eval_dyad_reshape(a, b):
+def eval_dyad_reshape(a, b, backend):
     """
 
         a:^b                                                   [Reshape]
@@ -840,51 +850,52 @@ def eval_dyad_reshape(a, b):
                     [2]:^[[1 2 3]] -->  [[1 2 3] [1 2 3]]
 
     """
+    np_backend = backend.np
     j = isinstance(b, str)
-    b = str_to_chr_arr(b) if j else b
-    if np.isarray(a):
-        if np.isarray(b):
-            y = np.where(a < 0)[0]
+    b = backend.str_to_chr_arr(b) if j else b
+    if np_backend.isarray(a):
+        if np_backend.isarray(b):
+            y = np_backend.where(a < 0)[0]
             if len(y) > 0:
-                a = np.copy(a)
-                a[y] = array_size(b) // 2
-            b_s = array_size(b)
-            a_s = int(np.prod(a))  # Ensure it's a Python int for comparison
-            # Convert shape to tuple of ints for torch compatibility
+                a = np_backend.copy(a)
+                a[y] = backend.array_size(b) // 2
+            b_s = backend.array_size(b)
+            a_s = int(np_backend.prod(a))  # Ensure it's a Python int for comparison
+            # Convert shape to tuple of ints for backend compatibility
             a_shape = tuple(int(x) for x in (a.tolist() if hasattr(a, 'tolist') else a))
             if a_s > b_s:
-                b = np.tile(b.flatten(), (a_s // b_s))
-                b = np.concatenate((b, b[:a_s - array_size(b)]))
-                b_s = array_size(b)
+                b = np_backend.tile(b.flatten(), (a_s // b_s))
+                b = np_backend.concatenate((b, b[:a_s - backend.array_size(b)]))
+                b_s = backend.array_size(b)
                 r = b.reshape(a_shape)
-                r = np.asarray(["".join(x) for x in r]) if j else r
+                r = np_backend.asarray(["".join(x) for x in r]) if j else r
                 j = False
             elif a_s == b_s:
                 r = b.reshape(a_shape)
             else:
-                r = np.resize(b, a_shape)
+                r = np_backend.resize(b, a_shape)
         else:
-            r = np.full(a, b)
+            r = np_backend.full(a, b)
     else:
         if a == 0:
             r = b
-        elif np.isarray(b):
+        elif np_backend.isarray(b):
             if a < b.shape[0]:
-                r = np.resize(b, (a,))
+                r = np_backend.resize(b, (a,))
             else:
-                ns = np.ones(len(b.shape),dtype=int)
+                ns = np_backend.ones(len(b.shape),dtype=int)
                 ns[0] = a // b.shape[0]
-                r = np.concatenate((np.tile(b,ns), b[:a - b.shape[0]*ns[0]]))
+                r = np_backend.concatenate((np_backend.tile(b,ns), b[:a - b.shape[0]*ns[0]]))
         else:
-            r = np.full((a,), b)
+            r = np_backend.full((a,), b)
     if j:
-        if np.isarray(r) and r.ndim > 1:
-            return np.asarray(["".join(x) for x in r], dtype=object)
+        if np_backend.isarray(r) and r.ndim > 1:
+            return np_backend.asarray(["".join(x) for x in r], dtype=object)
         return "".join(r)
     return r
 
 
-def eval_dyad_rotate(a, b):
+def eval_dyad_rotate(a, b, backend):
     """
 
         a:+b                                                    [Rotate]
@@ -911,12 +922,12 @@ def eval_dyad_rotate(a, b):
     if a == 0 or not is_iterable(b):
         return b
     j = isinstance(b, str)
-    b = str_to_chr_arr(b) if j else b
-    r = np.roll(b, a)
+    b = backend.str_to_chr_arr(b) if j else b
+    r = bknp.roll(b, a)
     return "".join(r) if j else r
 
 
-def eval_dyad_split(a, b):
+def eval_dyad_split(a, b, backend):
     """
 
         a:#b                                                     [Split]
@@ -935,12 +946,12 @@ def eval_dyad_split(a, b):
 
     """
     if len(b) == 0:
-        return np.asarray([])
+        return bknp.asarray([])
 
     j = isinstance(b, str)
-    b = str_to_chr_arr(b) if j else b
+    b = backend.str_to_chr_arr(b) if j else b
 
-    a = a if np.isarray(a) else [a]
+    a = a if bknp.isarray(a) else [a]
     if len(a) == 1:
         if a[0] >= len(b):
             r = [b]
@@ -948,7 +959,7 @@ def eval_dyad_split(a, b):
             k = len(b) // a[0]
             if (k*a[0]) < len(b):
                 k += 1
-            r = np.array_split(b, k)
+            r = bknp.array_split(b, k)
     else:
         p, q = 0, 0
         r = []
@@ -959,10 +970,10 @@ def eval_dyad_split(a, b):
             if p >= len(a):
                 p = 0
 
-    return np.asarray(["".join(x) for x in r],dtype=object) if j else kg_asarray(r)
+    return bknp.asarray(["".join(x) for x in r],dtype=object) if j else backend.kg_asarray(r)
 
 
-def eval_dyad_subtract(a, b):
+def eval_dyad_subtract(a, b, backend):
     """
 
         a-b                                                      [Minus]
@@ -977,10 +988,10 @@ def eval_dyad_subtract(a, b):
                   1-0.3  -->  0.7
 
     """
-    return np.subtract(a, b)
+    return backend.np.subtract(a, b)
 
 
-def eval_dyad_take(a, b):
+def eval_dyad_take(a, b, backend):
     """
 
         a#b                                                       [Take]
@@ -1003,16 +1014,18 @@ def eval_dyad_take(a, b):
                            0#""  -->  ""
 
     """
+    np_backend = backend.np
     j = isinstance(b,str)
-    b = str_to_chr_arr(b) if j else np.asarray(b)
-    aa = int(np.abs(a)) if hasattr(np.abs(a), 'item') else np.abs(a)  # Convert tensor to int
-    b_size = array_size(b)
+    b = backend.str_to_chr_arr(b) if j else np_backend.asarray(b)
+    abs_a = np_backend.abs(a)
+    aa = int(abs_a) if hasattr(abs_a, 'item') else abs_a  # Convert tensor to int
+    b_size = backend.array_size(b)
     if b_size == 0:
         # Handle empty array/string case
         r = b
     elif aa > b_size:
-        b = np.tile(b, aa // len(b))
-        b = np.concatenate((b, b[:aa-array_size(b)]) if a > 0 else (b[-(aa-array_size(b)):], b))
+        b = np_backend.tile(b, aa // len(b))
+        b = np_backend.concatenate((b, b[:aa-backend.array_size(b)]) if a > 0 else (b[-(aa-backend.array_size(b)):], b))
         r = b[a:] if a < 0 else b[:a]
     else:
         r = b[a:] if a < 0 else b[:a]
@@ -1106,21 +1119,49 @@ def eval_dyad_autograd(klong, a, b):
 
 
 def create_dyad_functions(klong):
-    def _get_name(s):
-        s = s.strip()
-        i = s.index("a")
-        return s[i+1:i+s.index('b')]
-
-    registry = {}
-
-    m = sys.modules[__name__]
-    for name in filter(lambda n: n.startswith("eval_dyad_"), dir(m)):
-        fn = getattr(m,name)
-        name = _get_name(fn.__doc__)
-        if fn.__code__.co_argcount == 3:
-            fn = lambda x,y,f=fn,klong=klong: f(klong, x, y)
-        elif fn.__code__.co_argcount == 2 and 'klong' in fn.__code__.co_varnames:
-            fn = lambda x,f=fn,klong=klong: f(klong, x)
-        registry[name] = fn
-
-    return registry
+    backend = klong._backend
+
+    # Simple dyads that don't need backend or klong
+    simple = {
+        ':-': eval_dyad_amend_in_depth,
+        '_': eval_dyad_drop,
+        ':@': eval_dyad_index_in_depth,
+    }
+
+    # Dyads needing backend
+    backend_dyads = {
+        '+': lambda a, b: eval_dyad_add(a, b, backend),
+        '|': lambda a, b: eval_dyad_maximum(a, b, backend),
+        '&': lambda a, b: eval_dyad_minimum(a, b, backend),
+        '!': lambda a, b: eval_dyad_remainder(a, b, backend),
+        '%': lambda a, b: eval_dyad_divide(a, b, backend),
+        '*': lambda a, b: eval_dyad_multiply(a, b, backend),
+        '-': lambda a, b: eval_dyad_subtract(a, b, backend),
+        ':=': lambda a, b: eval_dyad_amend(a, b, backend),
+        ':_': lambda a, b: eval_dyad_cut(a, b, backend),
+        '=': lambda a, b: eval_dyad_equal(a, b, backend),
+        '?': lambda a, b: eval_dyad_find(a, b, backend),
+        ':$': lambda a, b: eval_dyad_form(a, b, backend),
+        '$': lambda a, b: eval_dyad_format2(a, b, backend),
+        ':%': lambda a, b: eval_dyad_integer_divide(a, b, backend),
+        ',': lambda a, b: eval_dyad_join(a, b, backend),
+        '<': lambda a, b: eval_dyad_less(a, b, backend),
+        '~': lambda a, b: eval_dyad_match(a, b, backend),
+        '>': lambda a, b: eval_dyad_more(a, b, backend),
+        '^': lambda a, b: eval_dyad_power(a, b, backend),
+        ':^': lambda a, b: eval_dyad_reshape(a, b, backend),
+        ':+': lambda a, b: eval_dyad_rotate(a, b, backend),
+        ':#': lambda a, b: eval_dyad_split(a, b, backend),
+        '#': lambda a, b: eval_dyad_take(a, b, backend),
+    }
+
+    # Dyads needing klong
+    klong_dyads = {
+        '@': lambda a, b: eval_dyad_at_index(klong, a, b),
+        '::': lambda a, b: eval_dyad_define(klong, a, b),
+        '∇': lambda a, b: eval_dyad_grad(klong, a, b),
+        '∂': lambda a, b: eval_dyad_jacobian(klong, a, b),
+        ':>': lambda a, b: eval_dyad_autograd(klong, a, b),
+    }
+
+    return {**simple, **backend_dyads, **klong_dyads}