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

klongpy/__init__.py

@@ -1,5 +1,4 @@
 from .interpreter import KlongInterpreter, KlongException
-from .backend import TorchUnsupportedDtypeError
 from .backends import (
     get_backend,
     register_backend,
@@ -11,7 +10,6 @@ from .backends import (
 __all__ = [
     "KlongInterpreter",
     "KlongException",
-    "TorchUnsupportedDtypeError",
     "UnsupportedDtypeError",
     "get_backend",
     "register_backend",

klongpy/adverbs.py

@@ -1,35 +1,9 @@
 from .core import *
-from .dyads import eval_dyad_add, eval_dyad_subtract, eval_dyad_multiply, eval_dyad_divide
-from .backend import kg_asarray, is_number, str_to_chr_arr, kg_equal
 import functools
 import itertools
 
 
-def get_adverb_fn(klong, s, arity):
-    if s == "'":
-        return eval_adverb_each2 if arity == 2 else eval_adverb_each
-    elif s == '/':
-        return eval_adverb_over_neutral if arity == 2 else eval_adverb_over
-    elif s == '\\':
-        return eval_adverb_scan_over_neutral if arity == 2 else eval_adverb_scan_over
-    elif s == '\\~':
-        return (lambda f,a,b,k=klong: eval_adverb_scan_while(k,f,a,b)) if arity == 2 else eval_adverb_scan_converging
-    elif s == '\\*':
-        return eval_adverb_scan_iterating
-    elif s == ':\\':
-        return eval_adverb_each_left
-    elif s == ':\'':
-        return eval_adverb_each_pair
-    elif s == ':/':
-        return eval_adverb_each_right
-    elif s == ':*':
-        return eval_dyad_adverb_iterate
-    elif s == ':~':
-        return (lambda f,a,b,k=klong: eval_adverb_while(k,f,a,b)) if arity == 2 else eval_adverb_converge
-    raise RuntimeError(f"unknown adverb: {s}")
-
-
-def eval_adverb_converge(f, a, op):
+def eval_adverb_converge(f, a, op, backend):
     """
         f:~a                                                  [Converge]
 
@@ -55,10 +29,10 @@ def eval_adverb_converge(f, a, op):
     def _e(p,q):
         if not isinstance(p, type(q)):
             return False
-        if is_number(p):
-            return np.isclose(p,q)
-        elif np.isarray(p):
-            return kg_equal(p,q)
+        if backend.is_number(p):
+            return backend.np.isclose(p,q)
+        elif backend.is_array(p):
+            return backend.kg_equal(p, q)
         return p == q
     x = f(a)
     xx = f(x)
@@ -68,7 +42,7 @@ def eval_adverb_converge(f, a, op):
     return x
 
 
-def eval_adverb_each(f, a, op):
+def eval_adverb_each(f, a, op, backend):
     """
 
         f'a                                                       [Each]
@@ -93,17 +67,17 @@ def eval_adverb_each(f, a, op):
             return a
         has_str = False
         r = []
-        for x in str_to_chr_arr(a):
+        for x in backend.str_to_chr_arr(a):
             u = f(x)
             has_str |= isinstance(u,str)
             r.append(u)
-        return ''.join(r) if has_str else kg_asarray(r)
+        return ''.join(r) if has_str else backend.kg_asarray(r)
     if is_iterable(a):
         r = [f(x) for x in a]
-        return a if is_empty(a) else kg_asarray(r)
+        return a if is_empty(a) else backend.kg_asarray(r)
     elif is_dict(a):
-        r = [f(kg_asarray(x)) for x in a.items()]
-        return kg_asarray(r)
+        r = [f(backend.kg_asarray(x)) for x in a.items()]
+        return backend.kg_asarray(r)
     return f(a)
 
 
@@ -125,14 +99,14 @@ def eval_adverb_each2(f, a, b):
 
     """
     if is_empty(a) or is_empty(b):
-        return np.asarray([]) if is_list(a) or is_list(b) else ""
+        return bknp.asarray([]) if is_list(a) or is_list(b) else ""
     if is_atom(a) and is_atom(b):
         return f(a,b)
-    r = np.asarray([f(x,y) for x,y in zip(a,b)])
+    r = bknp.asarray([f(x,y) for x,y in zip(a,b)])
     return ''.join(r) if r.dtype == '<U1' else r
 
 
-def eval_adverb_each_left(f, a, b):
+def eval_adverb_each_left(f, a, b, backend):
     """
         a f:\b                                              [Each-Left]
         a f:/b                                              [Each-Right]
@@ -154,20 +128,19 @@ def eval_adverb_each_left(f, a, b):
         Examples: 1,:\[2 3 4]  -->  [[1 2] [1 3] [1 4]]
                   1,:/[2 3 4]  -->  [[2 1] [3 1] [4 1]]
     """
-    b = str_to_chr_arr(b) if isinstance(b,str) else b
-    return kg_asarray([f(a,x) for x in b])
+    b = backend.str_to_chr_arr(b) if isinstance(b,str) else b
+    return backend.kg_asarray([f(a,x) for x in b])
 
 
-def eval_adverb_each_right(f, a, b):
+def eval_adverb_each_right(f, a, b, backend):
     """
     see: eval_dyad_adverb_each_left
     """
-    b = str_to_chr_arr(b) if isinstance(b,str) else b
-    return kg_asarray([f(x,a) for x in b])
+    b = backend.str_to_chr_arr(b) if isinstance(b,str) else b
+    return backend.kg_asarray([f(x,a) for x in b])
 
 
-
-def eval_adverb_each_pair(f, a, op):
+def eval_adverb_each_pair(f, a, op, backend):
     """
 
         f:'a                                                 [Each-Pair]
@@ -186,8 +159,8 @@ def eval_adverb_each_pair(f, a, op):
     if is_atom(a) or (is_iterable(a) and len(a) == 1):
         return a
     j = isinstance(a, str)
-    a = str_to_chr_arr(a) if j else a
-    return kg_asarray([f(x,y) for x,y in zip(a[::],a[1::])])
+    a = backend.str_to_chr_arr(a) if j else a
+    return backend.kg_asarray([f(x,y) for x,y in zip(a[::],a[1::])])
 
 
 def eval_dyad_adverb_iterate(f, a, b):
@@ -209,7 +182,7 @@ def eval_dyad_adverb_iterate(f, a, b):
     return b
 
 
-def eval_adverb_over(f, a, op):
+def eval_adverb_over(f, a, op, backend):
     """
         f/a                                                       [Over]
 
@@ -228,22 +201,23 @@ def eval_adverb_over(f, a, op):
         return a
     if len(a) == 1:
         return a[0]
-    # Use NumPy/PyTorch ufunc reduce when available for better performance
+    # Use backend's ufunc reduce when available for better performance
+    np_backend = backend.np
     if isinstance(op, KGOp):
         if safe_eq(op.a,'+'):
-            return np.add.reduce(a)
+            return np_backend.add.reduce(a)
         elif safe_eq(op.a, '-'):
-            return np.subtract.reduce(a)
-        elif safe_eq(op.a, '*') and hasattr(np.multiply,'reduce'):
-            return np.multiply.reduce(a)
-        elif safe_eq(op.a, '%') and hasattr(np.divide,'reduce'):
-            return np.divide.reduce(a)
+            return np_backend.subtract.reduce(a)
+        elif safe_eq(op.a, '*') and hasattr(np_backend.multiply,'reduce'):
+            return np_backend.multiply.reduce(a)
+        elif safe_eq(op.a, '%') and hasattr(np_backend.divide,'reduce'):
+            return np_backend.divide.reduce(a)
         elif safe_eq(op.a, '&') and a.ndim == 1:
-            return np.min(a)
+            return np_backend.min(a)
         elif safe_eq(op.a, '|') and a.ndim == 1:
-            return np.max(a)
-        elif safe_eq(op.a, ',') and np.isarray(a) and a.dtype != 'O':
-            return a if a.ndim == 1 else np.concatenate(a, axis=0)
+            return np_backend.max(a)
+        elif safe_eq(op.a, ',') and np_backend.isarray(a) and a.dtype != 'O':
+            return a if a.ndim == 1 else np_backend.concatenate(a, axis=0)
     return functools.reduce(f, a)
 
 
@@ -280,7 +254,7 @@ def eval_adverb_over_neutral(f, a, b):
     return functools.reduce(f,b[1:],f(a,b[0]))
 
 
-def eval_adverb_scan_over_neutral(f, a, b):
+def eval_adverb_scan_over_neutral(f, a, b, backend):
     """
 
         f\a                                                  [Scan-Over]
@@ -309,31 +283,33 @@ def eval_adverb_scan_over_neutral(f, a, b):
         b = [b]
     b = [f(a,b[0]), *b[1:]]
     r = list(itertools.accumulate(b,f))
-    q = kg_asarray(r)
+    q = backend.kg_asarray(r)
     r = [a, *q]
-    return kg_asarray(r)
+    return backend.kg_asarray(r)
 
 
-def eval_adverb_scan_over(f, a, op):
+def eval_adverb_scan_over(f, a, op, backend):
     """
         see eval_adverb_scan_over_neutral
     """
     if is_atom(a):
         return a
-    # Use NumPy/PyTorch ufunc accumulate when available for better performance
-    if safe_eq(f, eval_dyad_add) and hasattr(np.add, 'accumulate'):
-        return np.add.accumulate(a)
-    elif safe_eq(f, eval_dyad_subtract) and hasattr(np.subtract, 'accumulate'):
-        return np.subtract.accumulate(a)
-    elif safe_eq(f, eval_dyad_multiply) and hasattr(np.multiple, 'accumulate'):
-        return np.multiple.accumulate(a)
-    elif safe_eq(f, eval_dyad_divide) and hasattr(np.divide, 'accumulate'):
-        return np.divide.accumulate(a)
+    # Use backend's ufunc accumulate when available for better performance
+    np_backend = backend.np
+    if isinstance(op, KGOp):
+        if safe_eq(op.a, '+') and hasattr(np_backend.add, 'accumulate'):
+            return np_backend.add.accumulate(a)
+        elif safe_eq(op.a, '-') and hasattr(np_backend.subtract, 'accumulate'):
+            return np_backend.subtract.accumulate(a)
+        elif safe_eq(op.a, '*') and hasattr(np_backend.multiply, 'accumulate'):
+            return np_backend.multiply.accumulate(a)
+        elif safe_eq(op.a, '%') and hasattr(np_backend.divide, 'accumulate'):
+            return np_backend.divide.accumulate(a)
     r = list(itertools.accumulate(a, f))
-    return kg_asarray(r)
+    return backend.kg_asarray(r)
 
 
-def eval_adverb_scan_converging(f, a, op):
+def eval_adverb_scan_converging(f, a, op, backend):
     """
 
         f\~a                                           [Scan-Converging]
@@ -356,15 +332,15 @@ def eval_adverb_scan_converging(f, a, op):
     x = a
     xx = f(a)
     r = [a, xx]
-    while not kg_equal(x,xx):
+    while not backend.kg_equal(x, xx):
         x = xx
         xx = f(x)
         r.append(xx)
     r.pop()
-    return kg_asarray(r)
+    return backend.kg_asarray(r)
 
 
-def eval_adverb_scan_while(klong, f, a, b):
+def eval_adverb_scan_while(klong, f, a, b, backend):
     """
 
         a f\~b                                              [Scan-While]
@@ -389,10 +365,10 @@ def eval_adverb_scan_while(klong, f, a, b):
         b = f(b)
         r.append(b)
     r.pop()
-    return kg_asarray(r)
+    return backend.kg_asarray(r)
 
 
-def eval_adverb_scan_iterating(f, a, b):
+def eval_adverb_scan_iterating(f, a, b, backend):
     """
 
         a f\*b                                          [Scan-Iterating]
@@ -410,7 +386,7 @@ def eval_adverb_scan_iterating(f, a, b):
         b = f(b)
         r.append(b)
         a = a - 1
-    return kg_asarray(r)
+    return backend.kg_asarray(r)
 
 
 def eval_adverb_while(klong, f, a, b):
@@ -429,3 +405,29 @@ def eval_adverb_while(klong, f, a, b):
     while klong.eval(KGCall(a, b, arity=1)):
         b = f(b)
     return b
+
+
+def get_adverb_fn(klong, s, arity):
+    backend = klong._backend
+
+    if s == "'":
+        return eval_adverb_each2 if arity == 2 else lambda f,a,op: eval_adverb_each(f,a,op,backend)
+    elif s == '/':
+        return eval_adverb_over_neutral if arity == 2 else lambda f,a,op: eval_adverb_over(f,a,op,backend)
+    elif s == '\\':
+        return (lambda f,a,b: eval_adverb_scan_over_neutral(f,a,b,backend)) if arity == 2 else lambda f,a,op: eval_adverb_scan_over(f,a,op,backend)
+    elif s == '\\~':
+        return (lambda f,a,b: eval_adverb_scan_while(klong,f,a,b,backend)) if arity == 2 else lambda f,a,op: eval_adverb_scan_converging(f,a,op,backend)
+    elif s == '\\*':
+        return lambda f,a,b: eval_adverb_scan_iterating(f,a,b,backend)
+    elif s == ':\\':
+        return lambda f,a,b: eval_adverb_each_left(f,a,b,backend)
+    elif s == ':\'':
+        return lambda f,a,op: eval_adverb_each_pair(f,a,op,backend)
+    elif s == ':/':
+        return lambda f,a,b: eval_adverb_each_right(f,a,b,backend)
+    elif s == ':*':
+        return eval_dyad_adverb_iterate
+    elif s == ':~':
+        return (lambda f,a,b: eval_adverb_while(klong,f,a,b)) if arity == 2 else lambda f,a,op: eval_adverb_converge(f,a,op,backend)
+    raise RuntimeError(f"unknown adverb: {s}")

klongpy/autograd.py

@@ -1,6 +1,5 @@
 import numpy as np
 from .core import KGLambda, KGCall, KGSym, KGFn
-from .backend import get_default_backend
 
 
 class AutogradError(Exception):
@@ -131,14 +130,6 @@ def grad_of_fn(klong, fn, x):
         return numeric_grad(call_fn, x, backend)
 
 
-def torch_autograd(func, x):
-    """Compute gradient using PyTorch autograd (requires torch backend)."""
-    backend = get_default_backend()
-    if not backend.supports_autograd():
-        raise RuntimeError("PyTorch autograd requires torch backend (USE_TORCH=1)")
-    return backend.compute_autograd(func, x)
-
-
 def numeric_jacobian(func, x, backend, eps=None):
     """
     Compute Jacobian matrix of func at point x using finite differences.

klongpy/backend.py

@@ -1,8 +1,7 @@
 """
-Backend compatibility module for KlongPy.
+Backend module for KlongPy.
 
-This module provides backward compatibility with the old global backend system.
-New code should use the backends package directly:
+Prefer using the backends package directly:
 
     from klongpy.backends import get_backend, BackendProvider
 
@@ -10,162 +9,30 @@ For per-interpreter backends, use:
 
     klong = KlongInterpreter(backend='torch')
 """
-import numpy as real_np
-
-from .backends import (
-    get_backend,
-    register_backend,
-    list_backends,
+from .backends.base import (
     BackendProvider,
     UnsupportedDtypeError,
-    TorchUnsupportedDtypeError,
-    NumpyBackendProvider,
-    TorchBackendProvider,
-    KGChar,
     is_jagged_array,
     is_supported_type,
 )
+from .backends.numpy_backend import KGChar, NumpyBackendProvider
+from .backends.registry import get_backend, list_backends, register_backend, TorchBackendProvider
 
-
-# Global backend state for backward compatibility
-# This is used by modules that import `np` and `use_torch` directly
-_default_backend = get_backend()
-
-# Backward compatibility: expose np and use_torch at module level
-np = _default_backend.np
-use_torch = _default_backend.name == 'torch'
-
-
-def get_default_backend():
-    """Get the default backend provider."""
-    return _default_backend
-
-
-def to_numpy(x):
-    """Convert tensor/array to numpy, handling device transfers and 0-dim arrays."""
-    result = _default_backend.to_numpy(x)
-    if isinstance(result, real_np.ndarray) and result.ndim == 0:
-        return result.item()
-    return result
-
-
-def to_display(x):
-    """Convert value to display-friendly format."""
-    return _default_backend.to_display(x)
-
-
-def array_size(a):
-    """
-    Get the total number of elements in an array/tensor.
-
-    Works with both numpy arrays and torch tensors.
-    """
-    return _default_backend.array_size(a)
-
-
-def safe_equal(x, y):
-    """Compare two values for equality, handling backend-specific array types."""
-    return _default_backend.safe_equal(x, y)
-
-
-def detach_if_needed(x):
-    """Detach array from computation graph if needed."""
-    return _default_backend.detach_if_needed(x)
-
-
-def to_int_array(a):
-    """Convert array to integer type."""
-    return _default_backend.to_int_array(a)
-
-
-def power(a, b):
-    """Compute a^b, handling gradient tracking if applicable."""
-    return _default_backend.power(a, b)
-
-
-def has_gradient(x):
-    """Check if x is tracking gradients (for autograd)."""
-    return _default_backend.has_gradient(x)
-
-
-def kg_asarray(a):
-    """Convert input to array using the default backend's kg_asarray method."""
-    return _default_backend.kg_asarray(a)
-
-
-def is_integer(x):
-    """Check if x is an integer type using the default backend."""
-    return _default_backend.is_integer(x)
-
-
-def is_float(x):
-    """Check if x is a float type using the default backend."""
-    return _default_backend.is_float(x)
-
-
-def is_number(a):
-    """Check if a is a number (integer or float) using the default backend."""
-    return _default_backend.is_number(a)
-
-
-def get_dtype_kind(arr):
-    """Get the dtype 'kind' character for an array using the default backend."""
-    return _default_backend.get_dtype_kind(arr)
-
-
-def str_to_chr_arr(s):
-    """Convert string to character array using the default backend."""
-    return _default_backend.str_to_chr_arr(s)
-
-
-def kg_argsort(a, descending=False):
-    """Argsort array using the default backend."""
-    from .core import kg_argsort as core_kg_argsort
-    return core_kg_argsort(a, _default_backend, descending=descending)
-
-
-def vec_fn(a, f):
-    """Apply a function f to an array a, with support for nested arrays."""
-    from .core import vec_fn as core_vec_fn
-    return core_vec_fn(a, f, _default_backend)
-
-
-def kg_equal(a, b):
-    """Compare two values or arrays for equality using the default backend."""
-    from .core import kg_equal as core_kg_equal
-    return core_kg_equal(a, b, _default_backend)
-
+_default_np_backend = get_backend('numpy')
+np = _default_np_backend.np
+bknp = np
 
 __all__ = [
     'np',
-    'use_torch',
+    'bknp',
     'get_backend',
-    'get_default_backend',
     'register_backend',
     'list_backends',
     'BackendProvider',
     'UnsupportedDtypeError',
-    'TorchUnsupportedDtypeError',
     'NumpyBackendProvider',
     'TorchBackendProvider',
     'KGChar',
     'is_supported_type',
     'is_jagged_array',
-    'to_numpy',
-    'to_display',
-    'array_size',
-    'safe_equal',
-    'detach_if_needed',
-    'to_int_array',
-    'power',
-    'has_gradient',
-    'kg_asarray',
-    'is_integer',
-    'is_float',
-    'is_number',
-    'get_dtype_kind',
-    'str_to_chr_arr',
-    'kg_argsort',
-    'vec_fn',
-    'kg_equal',
 ]

klongpy/backends/__init__.py

@@ -1,94 +1,26 @@
 """
-Backend registry for KlongPy.
+Backend public API for KlongPy.
 
-Provides a unified interface for registering and retrieving array backends.
-The default backend is 'numpy'.
+Re-exports registry helpers and core backend types.
 """
-import os
-
-from .base import BackendProvider, UnsupportedDtypeError, is_jagged_array, is_supported_type
+from .base import (
+    BackendProvider,
+    UnsupportedDtypeError,
+    is_jagged_array,
+    is_supported_type,
+)
 from .numpy_backend import NumpyBackendProvider, KGChar
-
-# Registry of available backends
-_BACKENDS = {}
-
-# Default backend name
-_DEFAULT_BACKEND = 'numpy'
-
-
-def register_backend(name: str, provider_class):
-    """Register a backend provider class."""
-    _BACKENDS[name] = provider_class
-
-
-def get_backend(name: str = None, **kwargs) -> BackendProvider:
-    """
-    Get a backend provider instance.
-
-    Parameters
-    ----------
-    name : str, optional
-        Backend name ('numpy' or 'torch'). If None, uses default.
-    **kwargs
-        Additional arguments passed to the backend provider constructor.
-
-    Returns
-    -------
-    BackendProvider
-        The backend provider instance.
-    """
-    if name is None:
-        # Check environment variable for default
-        env_backend = os.environ.get('KLONGPY_BACKEND', '').lower()
-        if env_backend == 'torch' or os.environ.get('USE_TORCH') == '1':
-            name = 'torch'
-        else:
-            name = _DEFAULT_BACKEND
-
-    if name not in _BACKENDS:
-        available = ', '.join(_BACKENDS.keys())
-        raise ValueError(f"Unknown backend: '{name}'. Available: {available}")
-
-    return _BACKENDS[name](**kwargs)
-
-
-def list_backends():
-    """Return list of available backend names."""
-    return list(_BACKENDS.keys())
-
-
-def set_default_backend(name: str):
-    """Set the default backend name."""
-    global _DEFAULT_BACKEND
-    if name not in _BACKENDS:
-        raise ValueError(f"Unknown backend: '{name}'")
-    _DEFAULT_BACKEND = name
-
-
-# Register built-in backends
-register_backend('numpy', NumpyBackendProvider)
-
-# Try to register torch backend if available
-try:
-    from .torch_backend import TorchBackendProvider, TorchUnsupportedDtypeError
-    register_backend('torch', TorchBackendProvider)
-except ImportError:
-    # Torch not available
-    TorchBackendProvider = None
-    TorchUnsupportedDtypeError = UnsupportedDtypeError
-
+from .registry import get_backend, list_backends, register_backend, TorchBackendProvider
 
 __all__ = [
     'BackendProvider',
     'UnsupportedDtypeError',
-    'TorchUnsupportedDtypeError',
     'NumpyBackendProvider',
     'TorchBackendProvider',
     'KGChar',
     'get_backend',
     'register_backend',
     'list_backends',
-    'set_default_backend',
     'is_jagged_array',
     'is_supported_type',
 ]