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

klongpy/dyads.py

@@ -1,5 +1,11 @@
 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):
@@ -181,7 +187,11 @@ def eval_dyad_at_index(klong, a, b):
         j = False
     else:
         r = a
-    return "".join(r) if j else r
+    if j:
+        if np.isarray(r) and r.ndim > 1:
+            return np.asarray(["".join(x) for x in r], dtype=object)
+        return "".join(r)
+    return r
 
 
 def eval_dyad_define(klong, n, v):
@@ -250,6 +260,11 @@ 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 eval_dyad_equal(a, b):
     """
 
@@ -275,7 +290,7 @@ def eval_dyad_equal(a, b):
                   [1 2 3]=[1 4 3]  -->  [1 0 1]
 
     """
-    return vec_fn2(a, b, lambda x, y: kg_truth(np.asarray(x,dtype=object) == np.asarray(y,dtype=object)))
+    return vec_fn2(a, b, _safe_equal)
 
 
 def finditer(s, sub):
@@ -401,9 +416,11 @@ def _e_dyad_format2(a, b):
     """
     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 np.asarray([vec_fn2(x, y, _e_dyad_format2) for x, y in zip(a, b)])
+    return __e_dyad_format2(a, b)
 
 def eval_dyad_format2(a, b):
     """
@@ -453,10 +470,10 @@ def eval_dyad_index_in_depth(a, b):
     return np.asarray(a)[tuple(b) if is_list(b) else b] if not is_empty(b) else b
 
 
-def _e_dyad_integer_divide(x,y):
+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 np.asarray(a,dtype='int') if np.isarray(a) else int(a)
+    a = kg_asarray(rec_fn(a, np.trunc)) if np.isarray(a) else a
+    return to_int_array(a)
 
 def eval_dyad_integer_divide(a, b):
     """
@@ -534,18 +551,28 @@ def eval_dyad_join(a, b):
         return b
 
     if np.isarray(a) and np.isarray(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))
+        # 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
+        if a_is_1d_plus and b_is_1d_plus:
+            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))
 
     aa = _arr_to_list(a)
     bb = _arr_to_list(b)
 
     r = [*aa,*bb]
     nr = kg_asarray(r)
-    t = nr.dtype.type
-    return nr if issubclass(t, np.integer) or issubclass(t, np.floating) else np.asarray(r,dtype=object)
+    # Check dtype kind for compatibility with both numpy and torch
+    dtype_kind = 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]
+    return numpy.asarray(r_numpy, dtype=object)
 
 
 def eval_dyad_less(a, b):
@@ -702,10 +729,26 @@ def eval_dyad_multiply(a, b):
     return np.multiply(a, b)
 
 
-def _e_dyad_power(a,b):
-    r = np.power(float(a) if is_integer(a) else a, b)
-    br = all([np.trunc(x) == x for x in r]) if is_list(r) else np.trunc(r) == r
-    return np.dtype('int').type(r) if br else r
+def _e_dyad_power(a, b):
+    # 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)
+    # 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)
+    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()
+        br = bool((trunc_r == r_val).all())
+    else:
+        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 r
 
 def eval_dyad_power(a, b):
     """
@@ -804,20 +847,22 @@ def eval_dyad_reshape(a, b):
             y = np.where(a < 0)[0]
             if len(y) > 0:
                 a = np.copy(a)
-                a[y] = b.size // 2
-            b_s = b.size
-            a_s = np.prod(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_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 - b.size]))
-                b_s = b.size
-                r = b.reshape(a)
+                b = np.concatenate((b, b[:a_s - array_size(b)]))
+                b_s = array_size(b)
+                r = b.reshape(a_shape)
                 r = np.asarray(["".join(x) for x in r]) if j else r
                 j = False
             elif a_s == b_s:
-                r = b.reshape(a)
+                r = b.reshape(a_shape)
             else:
-                r = np.resize(b, a)
+                r = np.resize(b, a_shape)
         else:
             r = np.full(a, b)
     else:
@@ -832,7 +877,11 @@ def eval_dyad_reshape(a, b):
                 r = np.concatenate((np.tile(b,ns), b[:a - b.shape[0]*ns[0]]))
         else:
             r = np.full((a,), b)
-    return "".join(r) if j else r
+    if j:
+        if np.isarray(r) and r.ndim > 1:
+            return np.asarray(["".join(x) for x in r], dtype=object)
+        return "".join(r)
+    return r
 
 
 def eval_dyad_rotate(a, b):
@@ -850,7 +899,7 @@ def eval_dyad_rotate(a, b):
         rotated will be a!#b.
 
         Note that n:+M rotates the rows of a matrix M (i.e. it rotates
-        it vertically); to rotate its columns (horizontally), use n:+:\M
+        it vertically); to rotate its columns (horizontally), use n:+:\\M
         (Rotate-Each-Left).
 
         Examples:           1:+[1 2 3 4 5]     -->  [5 1 2 3 4]
@@ -956,14 +1005,106 @@ def eval_dyad_take(a, b):
     """
     j = isinstance(b,str)
     b = str_to_chr_arr(b) if j else np.asarray(b)
-    aa = np.abs(a)
-    if aa > b.size:
-        b = np.tile(b,aa // len(b))
-        b = np.concatenate((b, b[:aa-b.size]) if a > 0 else (b[-(aa-b.size):],b))
-    r = b[a:] if a < 0 else b[:a]
+    aa = int(np.abs(a)) if hasattr(np.abs(a), 'item') else np.abs(a)  # Convert tensor to int
+    b_size = 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))
+        r = b[a:] if a < 0 else b[:a]
+    else:
+        r = b[a:] if a < 0 else b[:a]
     return "".join(r) if j else r
 
 
+def eval_dyad_grad(klong, a, b):
+    """
+
+        a∇b                                                    [Grad]
+
+        Compute the numeric gradient of the monadic function ``b`` at ``a``
+        using finite differences. Always uses numeric differentiation.
+
+        For automatic differentiation, use the :> operator instead.
+
+    """
+    def call_fn(v):
+        if isinstance(b, (KGSym, KGLambda, KGFn, KGCall)):
+            return klong.call(KGCall(b, [v], 1))
+        return b(v)
+
+    if isinstance(a, KGSym):
+        orig = klong[a]
+
+        def func(v):
+            klong[a] = v
+            try:
+                return call_fn(v)
+            finally:
+                klong[a] = orig
+
+        return numeric_grad(func, orig, klong._backend)
+    else:
+        return numeric_grad(call_fn, a, klong._backend)
+
+
+def eval_dyad_jacobian(klong, a, b):
+    """
+
+        a∂b                                                  [Jacobian]
+
+        Compute Jacobian matrix of function ``b`` at point ``a``.
+        For f: R^n -> R^m, returns m x n matrix where J[i,j] = df_i/dx_j.
+
+        Two modes based on what ``a`` contains:
+        1. Single point: [1 2]∂f -> Jacobian at that point
+        2. List of symbols: [w b]∂f -> [J_w J_b] (multi-param mode)
+
+        In multi-param mode, ``b`` should be a niladic function
+        that references the parameter symbols.
+
+        Examples:
+            [1 2]∂{[x@0^2 x@1^2]}  -->  [[2 0] [0 4]]
+            [w b]∂f               -->  [J_w J_b] (multi-param mode)
+
+    """
+    # Check if a is a list of symbols (multi-param mode)
+    if is_list(a) and len(a) > 0 and all(isinstance(p, KGSym) for p in a):
+        return multi_jacobian_of_fn(klong, b, list(a))
+    else:
+        return jacobian_of_fn(klong, b, a)  # Note: a is point, b is function
+
+
+def eval_dyad_autograd(klong, a, b):
+    """
+
+        a:>b                                                 [Autograd]
+
+        Compute gradient of function ``a`` with respect to ``b``.
+
+        Two modes based on what ``b`` contains:
+        1. Single param/point: a:>x or a:>[1 2 3] -> gradient at that point
+        2. List of symbols: a:>[w b] -> [grad_w grad_b] (multi-param mode)
+
+        In multi-param mode, ``a`` should be a niladic function (loss)
+        that references the parameter symbols.
+
+        Examples:
+            {x^2}:>3.0       -->  6.0      (derivative of x^2 at x=3)
+            {x^3}:>2.0       -->  12.0     (derivative of x^3 at x=2)
+            {+/x^2}:>[1 2 3] -->  [2 4 6]  (gradient of sum of squares)
+            loss:>[w b]      -->  [grad_w grad_b]  (multi-param mode)
+
+    """
+    # Check if b is a list of symbols (multi-param mode)
+    if is_list(b) and len(b) > 0 and all(isinstance(p, KGSym) for p in b):
+        return multi_grad_of_fn(klong, a, list(b))
+    else:
+        return grad_of_fn(klong, a, b)
+
+
 def create_dyad_functions(klong):
     def _get_name(s):
         s = s.strip()

klongpy/interpreter.py

@@ -2,10 +2,13 @@ import time
 from collections import deque
 
 from .adverbs import get_adverb_fn
+from .backends import get_backend
 from .core import *
+from .backend import is_number
 from .dyads import create_dyad_functions
 from .monads import create_monad_functions
 from .sys_fn import create_system_functions
+from .sys_fn_autograd import create_system_functions_autograd
 from .sys_fn_ipc import create_system_functions_ipc, create_system_var_ipc
 from .sys_fn_timer import create_system_functions_timer
 from .sys_var import *
@@ -141,6 +144,7 @@ def create_system_contexts():
 
     sys_d = {}
     add_context_key_values(sys_d, create_system_functions())
+    add_context_key_values(sys_d, create_system_functions_autograd())
     add_context_key_values(sys_d, create_system_functions_ipc())
     add_context_key_values(sys_d, create_system_functions_timer())
     set_context_var(sys_d, KGSym('.e'), eval_sys_var_epsilon()) # TODO: support lambda
@@ -210,13 +214,36 @@ def chain_adverbs(klong, arr):
 
 class KlongInterpreter():
 
-    def __init__(self):
+    def __init__(self, backend=None, device=None):
+        """
+        Initialize a Klong interpreter.
+
+        Parameters
+        ----------
+        backend : str, optional
+            Backend name ('numpy' or 'torch'). If None, uses the default
+            backend (numpy, unless KLONGPY_BACKEND or USE_TORCH env vars are set).
+        device : str, optional
+            Device for torch backend ('cpu', 'cuda', 'mps'). Only applies
+            when backend='torch'. If None, auto-selects best available device.
+        """
+        self._backend = get_backend(backend, device=device)
         self._context = KlongContext(create_system_contexts())
         self._vd = create_dyad_functions(self)
         self._vm = create_monad_functions(self)
         self._start_time = time.time()
         self._module = None
 
+    @property
+    def backend(self):
+        """Return the backend provider for this interpreter."""
+        return self._backend
+
+    @property
+    def np(self):
+        """Return the numpy-compatible array module for this interpreter."""
+        return self._backend.np
+
     def __setitem__(self, k, v):
         k = k if isinstance(k, KGSym) else KGSym(k)
         self._context[k] = v
@@ -224,7 +251,8 @@ class KlongInterpreter():
     def __getitem__(self, k):
         k = k if isinstance(k, KGSym) else KGSym(k)
         r = self._context[k]
-        return KGFnWrapper(self, r) if issubclass(type(r), KGFn) else r
+        # Pass the symbol name to avoid O(n) context search
+        return KGFnWrapper(self, r, sym=k) if issubclass(type(r), KGFn) else r
 
     def __delitem__(self, k):
         k = k if isinstance(k, KGSym) else KGSym(k)
@@ -618,7 +646,7 @@ class KlongInterpreter():
                 f = self._get_op_fn(x.a.a, x.a.arity)
                 fa = (x.args if isinstance(x.args, list) else [x.args]) if x.args is not None else x.args
                 _y = self.eval(fa[1]) if x.a.arity == 2 else None
-                _x = fa[0] if x.a.a == '::' else self.eval(fa[0])
+                _x = fa[0] if x.a.a in ['::','∇'] else self.eval(fa[0])
                 return f(_x) if x.a.arity == 1 else f(_x, _y)
             elif x.is_adverb_chain():
                 return chain_adverbs(self, x.a)()

klongpy/lib/help.kg

@@ -30,8 +30,8 @@ op.db::[
  [" a:$b" "Form"
   "b=string; convert 'b' to an object of the same form (type) as 'a'"]
  [" $a" "Format" "convert 'a' to a string representing the value of 'a'"]
- [" a$b" "Format2"
-  "a=real; Format 'b', pad with 'a' blanks or to align to x.y digits"]
+[" a$b" "Format2"
+ "a=real|list; when both operands are lists, apply pairwise. Format 'b', pad with 'a' blanks or to align to x.y digits"]
  [" >a" "Grade-Down"
   "a=vector; vector of indices of elements of 'a' in ascending order"]
  [" <a" "Grade-Up"

klongpy/monads.py

@@ -1,4 +1,8 @@
 from .core import *
+from .autograd import grad_of_fn
+from .backend import (
+    kg_asarray, is_integer, is_number, str_to_chr_arr, kg_argsort, array_size, vec_fn
+)
 import sys
 
 def eval_monad_atom(a):
@@ -74,7 +78,8 @@ def eval_monad_expand_where(a):
                   &[0 1 0 1 0]  -->   [1 3]
 
     """
-    return np.concatenate([np.zeros(x, dtype=int) + i for i,x in enumerate(a if is_list(a) else [a])])
+    arr = a if is_list(a) else [a]
+    return np.repeat(np.arange(len(arr)), arr)
 
 
 def eval_monad_first(a):
@@ -114,7 +119,15 @@ def eval_monad_floor(a):
                   _1e100  -->  1.0e+100  :"if precision < 100 digits"
 
     """
-    return vec_fn(a, lambda x: np.floor(np.asarray(x, dtype=float)).astype(int))
+    def _floor_to_int(x):
+        result = np.floor(np.asarray(x, dtype=float))
+        # Handle both numpy arrays and torch tensors
+        if hasattr(result, 'astype'):
+            return result.astype(int)
+        elif hasattr(result, 'to'):  # torch tensor - .to(int) works
+            return result.to(int)
+        return int(result)
+    return vec_fn(a, _floor_to_int)
 
 
 def eval_monad_format(a):
@@ -163,7 +176,7 @@ def eval_monad_grade_up(a):
                     >[[1] [2] [3]]  -->  [2 1 0]
 
     """
-    return kg_argsort(str_to_chr_arr(a) if isinstance(a,str) else a)
+    return kg_argsort(kg_asarray(a))
 
 
 def eval_monad_grade_down(a):
@@ -174,7 +187,7 @@ def eval_monad_grade_down(a):
         See [Grade-Up].
 
     """
-    return kg_argsort(str_to_chr_arr(a) if isinstance(a,str) else a, descending=True)
+    return kg_argsort(kg_asarray(a), descending=True)
 
 
 def eval_monad_groupby(a):
@@ -194,12 +207,12 @@ def eval_monad_groupby(a):
                   ="hello foo"  -->  [[0] [1] [2 3] [4 7 8] [5] [6]]
 
     """
-    q = np.asarray(str_to_chr_arr(a) if isinstance(a, str) else a)
-    if len(q) == 0:
-        return q
-    a = q.argsort()
-    r = np.split(a, np.where(q[a][1:] != q[a][:-1])[0] + 1)
-    return np.asarray(r, dtype=object)
+    arr = kg_asarray(a)
+    if array_size(arr) == 0:
+        return arr
+    vals, inverse = np.unique(arr, return_inverse=True)
+    groups = [np.where(inverse == i)[0] for i in range(len(vals))]
+    return kg_asarray(groups)
 
 
 def eval_monad_list(a):
@@ -214,10 +227,10 @@ def eval_monad_list(a):
                   ,"xyz" -->  ["xyz"]
                    ,[1]  -->  [[1]]
     """
-    if isinstance(a, KGChar):
+    if is_char(a):
         return str(a)
     if isinstance(a, KGSym):
-        np.asarray([a],dtype=object) # np interpets ':foo" as ':fo"
+        return np.asarray([a],dtype=object) # np interprets ':foo" as ':fo"
     return np.asarray([a])
 
 
@@ -452,6 +465,28 @@ def eval_monad_undefined(a):
     return kg_truth(a is None or (np.isinf(a) if is_number(a) else False))
 
 
+def eval_monad_track(a):
+    """
+
+        ˙a                                                    [Track]
+
+        Identity operator used when marking values for gradient tracking.
+
+    """
+    return a
+
+
+def eval_monad_grad(klong, a):
+    """
+
+        ∇a                                                     [Grad]
+
+        Return a function that computes the numeric gradient of ``a``.
+
+    """
+    return KGLambda(lambda x, fn=a, k=klong: grad_of_fn(k, fn, x))
+
+
 def create_monad_functions(klong):
     def _get_name(s):
         s = s.strip()
@@ -463,6 +498,8 @@ def create_monad_functions(klong):
     for x in filter(lambda n: n.startswith("eval_monad_"), dir(m)):
         fn = getattr(m,x)
         name = _get_name(fn.__doc__)
+        if fn.__code__.co_argcount == 2 and 'klong' in fn.__code__.co_varnames:
+            fn = lambda a,f=fn,klong=klong: f(klong, a)
         registry[name] = fn
 
     return registry

klongpy/repl.py

@@ -0,0 +1,91 @@
+import asyncio
+import threading
+import time
+import os
+import importlib.resources
+from typing import Optional
+
+from . import KlongInterpreter
+from .utils import CallbackEvent
+
+
+class LoopStopper:
+    def __init__(self, loop: asyncio.AbstractEventLoop) -> None:
+        self._loop = loop
+        self._future = loop.create_future()
+
+    def set(self) -> None:
+        if self._future.done():
+            return
+        if self._loop.is_running():
+            self._loop.call_soon_threadsafe(self._future.set_result, None)
+        else:
+            self._future.set_result(None)
+
+    async def wait(self) -> None:
+        await self._future
+
+
+def start_loop(loop: asyncio.AbstractEventLoop, stop_event: LoopStopper) -> None:
+    asyncio.set_event_loop(loop)
+    loop.run_until_complete(stop_event.wait())
+
+
+def setup_async_loop(debug: bool = False, slow_callback_duration: float = 86400.0):
+    loop = asyncio.new_event_loop()
+    loop.slow_callback_duration = slow_callback_duration
+    if debug:
+        loop.set_debug(True)
+    stop_event = LoopStopper(loop)
+    thread = threading.Thread(target=start_loop, args=(loop, stop_event), daemon=True)
+    thread.start()
+    return loop, thread, stop_event
+
+
+def cleanup_async_loop(loop: asyncio.AbstractEventLoop, loop_thread: threading.Thread, stop_event: LoopStopper, debug: bool = False, name: Optional[str] = None) -> None:
+    if loop.is_closed():
+        return
+
+    loop.call_soon_threadsafe(stop_event.set)
+    loop_thread.join()
+
+    pending_tasks = asyncio.all_tasks(loop=loop)
+    if len(pending_tasks) > 0:
+        if name:
+            print(f"WARNING: pending tasks in {name} loop")
+        for task in pending_tasks:
+            loop.call_soon_threadsafe(task.cancel)
+        while len(asyncio.all_tasks(loop=loop)) > 0:
+            time.sleep(0)
+
+    loop.stop()
+
+    if not loop.is_closed():
+        loop.close()
+
+
+def append_pkg_resource_path_KLONGPATH() -> None:
+    with importlib.resources.as_file(importlib.resources.files('klongpy')) as pkg_path:
+        pkg_lib_path = os.path.join(pkg_path, 'lib')
+        klongpath = os.environ.get('KLONGPATH', '.:lib')
+        klongpath = f"{klongpath}:{pkg_lib_path}" if klongpath else str(pkg_lib_path)
+        os.environ['KLONGPATH'] = klongpath
+
+
+def create_repl(debug: bool = False):
+    io_loop, io_thread, io_stop = setup_async_loop(debug=debug)
+    klong_loop, klong_thread, klong_stop = setup_async_loop(debug=debug)
+
+    append_pkg_resource_path_KLONGPATH()
+
+    klong = KlongInterpreter()
+    shutdown_event = CallbackEvent()
+    klong['.system'] = {'ioloop': io_loop, 'klongloop': klong_loop, 'closeEvent': shutdown_event}
+
+    return klong, (io_loop, io_thread, io_stop, klong_loop, klong_thread, klong_stop)
+
+
+def cleanup_repl(loops, debug: bool = False) -> None:
+    io_loop, io_thread, io_stop, klong_loop, klong_thread, klong_stop = loops
+    cleanup_async_loop(io_loop, io_thread, io_stop, debug=debug, name='io_loop')
+    cleanup_async_loop(klong_loop, klong_thread, klong_stop, debug=debug, name='klong_loop')