klongpy 0.6.9__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):
@@ -254,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):
     """
 
@@ -279,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):
@@ -459,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):
     """
@@ -540,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):
@@ -708,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):
     """
@@ -810,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:
@@ -860,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]
@@ -966,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/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):
@@ -115,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):
@@ -196,7 +208,7 @@ def eval_monad_groupby(a):
 
     """
     arr = kg_asarray(a)
-    if arr.size == 0:
+    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))]
@@ -215,7 +227,7 @@ def eval_monad_list(a):
                   ,"xyz" -->  ["xyz"]
                    ,[1]  -->  [[1]]
     """
-    if isinstance(a, KGChar):
+    if is_char(a):
         return str(a)
     if isinstance(a, KGSym):
         return np.asarray([a],dtype=object) # np interprets ':foo" as ':fo"
@@ -453,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()
@@ -464,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

@@ -3,12 +3,30 @@ import threading
 import time
 import os
 import importlib.resources
+from typing import Optional
 
 from . import KlongInterpreter
 from .utils import CallbackEvent
 
 
-def start_loop(loop: asyncio.AbstractEventLoop, stop_event: asyncio.Event) -> None:
+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())
 
@@ -18,13 +36,13 @@ def setup_async_loop(debug: bool = False, slow_callback_duration: float = 86400.
     loop.slow_callback_duration = slow_callback_duration
     if debug:
         loop.set_debug(True)
-    stop_event = asyncio.Event()
+    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: asyncio.Event, debug: bool = False, name: str | None = None) -> None:
+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
 

klongpy/sys_fn.py

@@ -12,8 +12,24 @@ from inspect import Parameter
 import numpy
 
 from .core import (KGChannel, KGChannelDir, KGLambda, KGSym, KlongException,
-                   is_dict, is_empty, is_list, kg_asarray, kg_read, kg_write, np,
+                   is_dict, is_empty, is_list, kg_read, kg_write, np,
                    reserved_fn_args, reserved_fn_symbol_map, safe_eq, safe_inspect)
+from .backend import to_numpy, get_default_backend, kg_asarray
+
+
+def _to_display_value(x):
+    """Convert backend tensors to numpy for cleaner display."""
+    backend = get_default_backend()
+    # Convert backend arrays (tensors) to numpy
+    if backend.is_backend_array(x):
+        return to_numpy(x)
+    # Handle numpy arrays with tensors inside (object arrays)
+    if isinstance(x, numpy.ndarray) and x.dtype == object:
+        return numpy.array([_to_display_value(item) for item in x], dtype=object)
+    # Handle lists with tensors
+    if isinstance(x, list):
+        return [_to_display_value(item) for item in x]
+    return x
 
 
 def eval_sys_append_channel(x):
@@ -47,10 +63,25 @@ def eval_sys_display(klong, x):
 
         .d(x)                                                  [Display]
 
-        See [Write].
+        Display the object "x". Tensors are converted to numpy for cleaner output.
+        Use .bkd() for raw backend-specific display.
+
+    """
+    x = _to_display_value(x)
+    r = kg_write(x, klong._backend, display=True)
+    klong['.sys.cout'].raw.write(r)
+    return r
+
+
+def eval_sys_backend_display(klong, x):
+    """
+
+        .bkd(x)                                        [Backend-Display]
+
+        Display the object "x" in raw backend format (tensors shown as-is).
 
     """
-    r = kg_write(x, display=True)
+    r = kg_write(x, klong._backend, display=True)
     klong['.sys.cout'].raw.write(r)
     return r
 
@@ -272,10 +303,26 @@ def eval_sys_print(klong, x):
         .p(x)                                                    [Print]
 
         Pretty-print the object "x" (like Display) and then print a
-        newline sequence. .p("") will just print a newline.
+        newline sequence. Tensors are converted to numpy for cleaner output.
+        Use .bkp() for raw backend-specific print.
+
+    """
+    x = _to_display_value(x)
+    o = kg_write(x, klong._backend, display=True)
+    klong['.sys.cout'].raw.write(o+"\n")
+    return o
+
+
+def eval_sys_backend_print(klong, x):
+    """
+
+        .bkp(x)                                          [Backend-Print]
+
+        Pretty-print the object "x" in raw backend format (tensors shown as-is)
+        and then print a newline sequence.
 
     """
-    o = kg_write(x, display=True)
+    o = kg_write(x, klong._backend, display=True)
     klong['.sys.cout'].raw.write(o+"\n")
     return o
 
@@ -341,20 +388,30 @@ def _handle_import(item):
             if n_args <= len(reserved_fn_args):
                 item = KGLambda(item, args=reserved_fn_args[:n_args])
         else:
-            args = safe_inspect(item, follow_wrapped=True)
-            if 'args' in args:
+            sig_args = safe_inspect(item, follow_wrapped=True)
+            if 'args' in sig_args:
                 item = KGLambda(item, args=None, wildcard=True)
                 n_args = 3
             else:
-                args = [k for k,v in args.items() if (v.kind == Parameter.POSITIONAL_OR_KEYWORD and v.default == Parameter.empty) or (v.kind == Parameter.POSITIONAL_ONLY)]
-                n_args = len(args)
-                # if there are kwargs, then .pyc() must be used to call this function to override them
-                if 'klong' in args:
-                    n_args -= 1
-                    assert n_args <= len(reserved_fn_args)
-                    item = KGLambda(item, args=reserved_fn_args[:n_args], provide_klong=True)
-                elif n_args <= len(reserved_fn_args):
-                    item = KGLambda(item, args=reserved_fn_args[:n_args])
+                # Get required args (no default)
+                required_args = [k for k,v in sig_args.items() if (v.kind == Parameter.POSITIONAL_OR_KEYWORD and v.default == Parameter.empty) or (v.kind == Parameter.POSITIONAL_ONLY)]
+                # Get optional args (have default)
+                optional_args = [k for k,v in sig_args.items() if v.kind == Parameter.POSITIONAL_OR_KEYWORD and v.default != Parameter.empty]
+                # Use required args count, but if there are optional args and no required args,
+                # use wildcard mode so the function can accept 0-3 args
+                if not required_args and optional_args:
+                    item = KGLambda(item, args=None, wildcard=True)
+                    n_args = 3
+                else:
+                    args = required_args
+                    n_args = len(args)
+                    # if there are kwargs, then .pyc() must be used to call this function to override them
+                    if 'klong' in args:
+                        n_args -= 1
+                        assert n_args <= len(reserved_fn_args)
+                        item = KGLambda(item, args=reserved_fn_args[:n_args], provide_klong=True)
+                    elif n_args <= len(reserved_fn_args):
+                        item = KGLambda(item, args=reserved_fn_args[:n_args])
     except Exception:
         if hasattr(item, "__class__") and hasattr(item.__class__, '__module__') and item.__class__.__module__ == "builtins":
             # LOOK AWAY. You didn't see this.
@@ -415,6 +472,17 @@ def _import_module(klong, x, from_set=None):
                 except Exception as e:
                     # TODO: this should be logged
                     print(f"failed to import function: {name}", e)
+
+            # For from_set imports, also check for lazy-loaded attributes not in __dict__
+            # (e.g., numpy.random in numpy 2.x)
+            if from_set is not None:
+                for name in from_set:
+                    if name not in export_items and hasattr(module, name):
+                        try:
+                            item = getattr(module, name)
+                            klong[name] = _handle_import(item)
+                        except Exception as e:
+                            print(f"failed to import function: {name}", e)
         finally:
             klong._context.push(ctx)
 
@@ -578,6 +646,49 @@ def eval_sys_python_from(klong, x, y):
     return _import_module(klong, x, from_set=set(y))
 
 
+def eval_sys_backend_fn(klong, x):
+    """
+
+        .bkf(x)                                           [Backend-Function]
+
+        Import functions from the current backend's array module.
+        This is similar to .pyf() but uses backend-aware functions that
+        work with both numpy and torch backends.
+
+        When using the torch backend, these functions preserve gradient
+        tracking for autograd.
+
+        Example:
+
+            .bkf("exp")
+            exp(1.0) --> 2.718...
+
+            .bkf(["exp";"sin";"cos"])
+            sin(1.0) --> 0.841...
+
+        Common functions available: exp, sin, cos, tan, tanh, sqrt, abs,
+        log, log10, floor, ceil, round
+
+    """
+    if isinstance(x, str):
+        x = [x]
+    if not (is_list(x) and all(map(lambda p: isinstance(p, str), x))):
+        raise RuntimeError("function name(s) must be a string or list of strings")
+
+    backend = klong._backend
+    ctx = klong._context.pop()
+    try:
+        for fn_name in x:
+            if hasattr(backend.np, fn_name):
+                fn = getattr(backend.np, fn_name)
+                klong[fn_name] = _handle_import(fn)
+            else:
+                raise RuntimeError(f"Backend does not have function: {fn_name}")
+    finally:
+        klong._context.push(ctx)
+    return None
+
+
 def eval_sys_random_number():
     """
 
@@ -722,7 +833,7 @@ def eval_sys_write(klong, x):
         sequence. Use .p (Print) to do so.
 
     """
-    r = kg_write(x)
+    r = kg_write(x, klong._backend)
     klong['.sys.cout'].raw.write(r)
     return x