taylorize 0.0.1__py3-none-any.whl

taylorize/__init__.py

@@ -0,0 +1,42 @@
+"""taylorize — lazy truncated Taylor series for higher-order automatic
+differentiation and Taylor-method ODE integration.
+
+A :class:`Taylor` is the normalized Taylor polynomial of a smooth function
+around a point.  Higher-order coefficients are computed lazily, so arbitrary
+orders can be requested *after* the expression has been built.
+
+This is the minimal 0.0.1 seed of the project.
+"""
+from .core import (
+    Taylor,
+    constant,
+    cos,
+    derivative,
+    exp,
+    log,
+    ode_step,
+    power,
+    sin,
+    sqrt,
+    tan,
+    taylor_series,
+    variable,
+)
+
+__version__ = "0.0.1"
+
+__all__ = [
+    "Taylor",
+    "variable",
+    "constant",
+    "exp",
+    "log",
+    "sin",
+    "cos",
+    "tan",
+    "sqrt",
+    "power",
+    "derivative",
+    "taylor_series",
+    "ode_step",
+]

taylorize/core.py

@@ -0,0 +1,345 @@
+"""Core: a small, dependency-free truncated Taylor series type.
+
+A :class:`Taylor` represents the normalized Taylor polynomial of a smooth
+function ``x(t)`` around ``t = 0``::
+
+    x(t) = c[0] + c[1] t + c[2] t^2 + ...
+
+with ``c[k] = x^(k)(0) / k!``.  Higher-order coefficients are produced lazily
+from a recurrence rule, so any order can be requested after the fact.
+"""
+from __future__ import annotations
+
+import math
+from typing import Callable, List, Optional
+
+__all__ = [
+    "Taylor",
+    "variable",
+    "constant",
+    "exp",
+    "log",
+    "sin",
+    "cos",
+    "tan",
+    "sqrt",
+    "power",
+    "derivative",
+    "taylor_series",
+    "ode_step",
+]
+
+
+class Taylor:
+    """A truncated Taylor polynomial with lazily computed coefficients."""
+
+    __slots__ = ("c", "_rule")
+
+    def __init__(self, coeffs, _rule: Optional[Callable[[int], object]] = None) -> None:
+        if isinstance(coeffs, Taylor):
+            self.c: List[object] = list(coeffs.c)
+            self._rule = coeffs._rule if _rule is None else _rule
+        elif isinstance(coeffs, (list, tuple)):
+            self.c = list(coeffs)
+            self._rule = _rule
+        else:
+            self.c = [coeffs]
+            self._rule = _rule
+        if not self.c:
+            raise ValueError("Taylor needs at least one coefficient.")
+
+    # -- coefficient access --------------------------------------------------
+    @property
+    def primal(self):
+        """The constant term ``c[0]``."""
+        return self.c[0]
+
+    @property
+    def order(self) -> int:
+        """Currently materialized truncation order."""
+        return len(self.c) - 1
+
+    def ensure(self, n: int) -> "Taylor":
+        """Materialize coefficients up to degree ``n`` (lazily if possible)."""
+        cur = len(self.c) - 1
+        if n > cur:
+            if self._rule is None:
+                self.c.extend([0] * (n - cur))
+            else:
+                for k in range(cur + 1, n + 1):
+                    self.c.append(self._rule(k))
+        return self
+
+    def coeff(self, k: int):
+        if k < 0:
+            raise IndexError(k)
+        if k >= len(self.c):
+            if self._rule is None:
+                return 0
+            self.ensure(k)
+        return self.c[k]
+
+    def __getitem__(self, k):
+        if isinstance(k, slice):
+            if k.stop is not None and k.stop > len(self.c):
+                self.ensure(k.stop - 1)
+            return self.c[k]
+        return self.coeff(k)
+
+    def eval(self, h, order: Optional[int] = None):
+        """Evaluate the polynomial at ``h`` with Horner's scheme."""
+        if order is not None:
+            self.ensure(order)
+            coeffs = self.c[: order + 1]
+        else:
+            coeffs = self.c
+        acc = 0
+        for c in reversed(coeffs):
+            acc = acc * h + c
+        return acc
+
+    def derivative(self, k: int):
+        """Return the unnormalized ``k``-th derivative at 0: ``k! * c[k]``."""
+        return self.coeff(k) * math.factorial(k)
+
+    def diff(self) -> "Taylor":
+        """Formal derivative ``x'(t)`` as a new lazy Taylor."""
+        return Taylor([self.coeff(1)], _rule=lambda k: (k + 1) * self.coeff(k + 1))
+
+    def integrate(self, c0=0) -> "Taylor":
+        """Formal integral with constant term ``c0``."""
+        return Taylor([c0], _rule=lambda k: self.coeff(k - 1) / k)
+
+    def __repr__(self) -> str:
+        return "Taylor([%s])" % ", ".join(repr(v) for v in self.c)
+
+    # -- arithmetic ----------------------------------------------------------
+    def __add__(self, other):
+        if not isinstance(other, Taylor):
+            return Taylor([self.c[0] + other], _rule=lambda k: self.coeff(k))
+        out = Taylor(
+            [self.primal + other.primal],
+            _rule=lambda k: self.coeff(k) + other.coeff(k),
+        )
+        out.ensure(max(self.order, other.order))
+        return out
+
+    __radd__ = __add__
+
+    def __neg__(self):
+        return Taylor([-self.primal], _rule=lambda k: -self.coeff(k))
+
+    def __sub__(self, other):
+        return self + (-_as_taylor(other))
+
+    def __rsub__(self, other):
+        return _as_taylor(other) - self
+
+    def __mul__(self, other):
+        if not isinstance(other, Taylor):
+            return Taylor([self.primal * other], _rule=lambda k: self.coeff(k) * other)
+        out = Taylor(
+            [self.primal * other.primal],
+            _rule=lambda k: sum(
+                self.coeff(j) * other.coeff(k - j) for j in range(k + 1)
+            ),
+        )
+        out.ensure(max(self.order, other.order))
+        return out
+
+    __rmul__ = __mul__
+
+    def __truediv__(self, other):
+        if not isinstance(other, Taylor):
+            if other == 0:
+                raise ZeroDivisionError("division of Taylor by zero")
+            return Taylor([self.primal / other], _rule=lambda k: self.coeff(k) / other)
+        y0 = other.primal
+        if y0 == 0:
+            raise ZeroDivisionError("division by Taylor with zero constant term")
+        out = Taylor([self.primal / y0])
+        out._rule = lambda k: (
+            self.coeff(k)
+            - sum(other.coeff(j) * out.coeff(k - j) for j in range(1, k + 1))
+        ) / y0
+        out.ensure(max(self.order, other.order))
+        return out
+
+    def __rtruediv__(self, other):
+        return _as_taylor(other) / self
+
+    def __pow__(self, p):
+        return power(self, p)
+
+    # -- elementary functions ------------------------------------------------
+    def exp(self) -> "Taylor":
+        out = Taylor([math.exp(self.primal)])
+        out._rule = (
+            lambda k: sum(j * self.coeff(j) * out.coeff(k - j) for j in range(1, k + 1))
+            / k
+        )
+        out.ensure(self.order)
+        return out
+
+    def log(self) -> "Taylor":
+        x0 = self.primal
+        if x0 <= 0:
+            raise ValueError("log requires a positive constant term.")
+        out = Taylor([math.log(x0)])
+        out._rule = lambda k: (
+            self.coeff(k)
+            - sum(j * out.coeff(j) * self.coeff(k - j) for j in range(1, k)) / k
+        ) / x0
+        out.ensure(self.order)
+        return out
+
+    def sqrt(self) -> "Taylor":
+        return power(self, 0.5)
+
+    def sin_cos(self):
+        s = Taylor([math.sin(self.primal)])
+        c = Taylor([math.cos(self.primal)])
+        s._rule = (
+            lambda k: sum(j * self.coeff(j) * c.coeff(k - j) for j in range(1, k + 1))
+            / k
+        )
+        c._rule = (
+            lambda k: -sum(j * self.coeff(j) * s.coeff(k - j) for j in range(1, k + 1))
+            / k
+        )
+        s.ensure(self.order)
+        c.ensure(self.order)
+        return s, c
+
+    def sin(self) -> "Taylor":
+        return self.sin_cos()[0]
+
+    def cos(self) -> "Taylor":
+        return self.sin_cos()[1]
+
+    def tan(self) -> "Taylor":
+        return self.sin() / self.cos()
+
+
+# -- helpers -----------------------------------------------------------------
+def _as_taylor(x) -> Taylor:
+    return x if isinstance(x, Taylor) else Taylor([x])
+
+
+def variable(x0, order: Optional[int] = None) -> Taylor:
+    """The independent variable, ``t = x0 + h``."""
+    t = Taylor([x0, 1] if order != 0 else [x0])
+    if order:
+        t.ensure(order)
+    return t
+
+
+def constant(c, order: Optional[int] = None) -> Taylor:
+    t = Taylor([c])
+    if order:
+        t.ensure(order)
+    return t
+
+
+def power(x, p) -> Taylor:
+    """``x ** p`` for a Taylor base and scalar (or Taylor) exponent."""
+    if isinstance(p, Taylor):
+        return (p * x.log()).exp()
+    if not isinstance(x, Taylor):
+        return x ** p
+    if isinstance(p, int):
+        if p == 0:
+            return constant(1, order=x.order)
+        if p < 0:
+            return constant(1) / power(x, -p)
+        result = constant(1)
+        base = x
+        e = p
+        while e:
+            if e & 1:
+                result = result * base
+            base = base * base
+            e >>= 1
+        return result
+    x0 = x.primal
+    p_plus_1 = p + 1
+    out = Taylor([x0 ** p])
+    out._rule = lambda k: (
+        sum((j * p_plus_1 - k) * x.coeff(j) * out.coeff(k - j) for j in range(1, k + 1))
+        / (k * x0)
+    )
+    out.ensure(x.order)
+    return out
+
+
+def exp(x):
+    return _as_taylor(x).exp()
+
+
+def log(x):
+    return _as_taylor(x).log()
+
+
+def sqrt(x):
+    return _as_taylor(x).sqrt()
+
+
+def sin(x):
+    return _as_taylor(x).sin()
+
+
+def cos(x):
+    return _as_taylor(x).cos()
+
+
+def tan(x):
+    return _as_taylor(x).tan()
+
+
+# -- JAX-style transforms ----------------------------------------------------
+def derivative(f: Callable, k: int = 1) -> Callable:
+    """Transform ``f`` into a function returning its ``k``-th derivative."""
+    if k < 0:
+        raise ValueError("k must be >= 0")
+
+    def grad_k(x0):
+        return f(variable(x0, order=k)).derivative(k)
+
+    grad_k.__name__ = getattr(f, "__name__", "grad_k")
+    return grad_k
+
+
+def taylor_series(f: Callable, order: int) -> Callable:
+    """Transform ``f`` into a function returning ``[c_0, ..., c_order]``."""
+    if order < 0:
+        raise ValueError("order must be >= 0")
+
+    def series_fn(x0):
+        return list(f(variable(x0, order=order)).ensure(order).c)
+
+    series_fn.__name__ = getattr(f, "__name__", "series_fn")
+    return series_fn
+
+
+def ode_step(f: Callable, order: int = 10) -> Callable:
+    """Transform a vector field ``f`` into an ``order``-th Taylor step.
+
+    The returned function ``step(x, dt, t=0.0)`` advances the state ``x``
+    (a scalar or a sequence) by a single Taylor-method step of size ``dt``.
+    The vector field is evaluated once per step on lazy Taylor jets.
+    """
+    if order < 1:
+        raise ValueError("order must be >= 1")
+
+    def step(x, dt, t=0.0):
+        scalar = not isinstance(x, (list, tuple))
+        xs = [x] if scalar else list(x)
+        jets = [Taylor([v]) for v in xs]
+        rhs = [f(jets[0])] if scalar else list(f(jets))
+        for jet, r in zip(jets, rhs):
+            jet._rule = (lambda k, r=r: r.coeff(k - 1) / k)
+        out = [jet.eval(dt, order=order) for jet in jets]
+        return out[0] if scalar else out
+
+    step.__name__ = "step"
+    return step

taylorize-0.0.1.dist-info/METADATA

@@ -0,0 +1,85 @@
+Metadata-Version: 2.5
+Name: taylorize
+Version: 0.0.1
+Summary: Lazy truncated Taylor series: higher-order automatic differentiation and arbitrary-precision Taylor-method ODE integration.
+Project-URL: Homepage, https://github.com/yonesuke/taylorize
+Project-URL: Repository, https://github.com/yonesuke/taylorize
+Project-URL: Issues, https://github.com/yonesuke/taylorize/issues
+Author: Ryosuke Yoneda
+License-Expression: MIT
+License-File: LICENSE
+Keywords: arbitrary-precision,automatic-differentiation,higher-order,ode,taylor-series
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# taylorize
+
+Lazy truncated Taylor series for **higher-order automatic differentiation** and
+**arbitrary-precision Taylor-method ODE integration**.
+
+`taylorize` represents a smooth function by its normalized Taylor coefficients
+`c[k] = x^(k)(0) / k!` and computes them **lazily**, so you can build an
+expression once and then ask for any order afterwards.
+
+> Status: **0.0.1 (pre-alpha seed)**. The API is minimal and will change.
+
+## Install
+
+```bash
+pip install taylorize
+```
+
+## Quickstart
+
+```python
+from taylorize import derivative, taylor_series, exp, sin, ode_step
+
+def f(x):
+    return exp(sin(x))
+
+# 5th derivative of exp(sin(x)) at 0
+print(derivative(f, k=5)(0.0))          # -8.0
+
+# Taylor coefficients of sin(x)
+print(taylor_series(sin, order=9)(0.0)) # [0, 1, 0, -1/6, ...]
+
+# One 16th-order Taylor step of the simple pendulum
+def pendulum(u):
+    theta, omega = u[0], u[1]
+    return [omega, -sin(theta)]
+
+step = ode_step(pendulum, order=16)
+print(step([1.0, 0.0], 0.1))
+```
+
+See [`examples/basic.py`](examples/basic.py).
+
+## Idea
+
+The core object is a truncated power series in a nilpotent direction `h`:
+
+```
+x(h) = c[0] + c[1] h + c[2] h^2 + ... + c[N] h^N
+```
+
+Every elementary function is just a recurrence on these coefficients
+(e.g. `exp`: `c[k] = (1/k) * sum(j * x[j] * c[k-j])`), and the chain rule turns
+any composition into ring operations on series. The same machinery integrates
+ODEs one Taylor step at a time.
+
+## Roadmap
+
+- Backend-agnostic coefficients (`math`, `numpy`, `mpmath`, `torch`, `jax`, `sympy`)
+- Automatic interception of `math.*` / `np.*` / `torch.*` / `sp.*`
+- Functions defined by ODEs (`from_ode`) and coupled systems
+- Special functions (`erf`, Airy, Bessel, Jacobi, ...)
+- Adaptive-step Taylor ODE solver
+
+## License
+
+MIT

taylorize-0.0.1.dist-info/RECORD

@@ -0,0 +1,6 @@
+taylorize/__init__.py,sha256=tmDWM513hO_VI3YrCx82HdvPHDQHv9NkJpawtV17eWY,788
+taylorize/core.py,sha256=__ZgTs0Tt9c1H5Ja51VrQkpy2RFBdanDw65MIilOvIw,10098
+taylorize-0.0.1.dist-info/METADATA,sha256=23rV_JMQpgCi-a6ugx8KrIe2JIeFB1DEkl7j5kHcpZE,2622
+taylorize-0.0.1.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+taylorize-0.0.1.dist-info/licenses/LICENSE,sha256=he91dD1MWO8087zdNhDvn4z-XVWS5joxWUBAFESRLS0,1071
+taylorize-0.0.1.dist-info/RECORD,,

taylorize-0.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.33.0
+Root-Is-Purelib: true
+Tag: py3-none-any

taylorize-0.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ryosuke Yoneda
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.