demathpy 0.1.0__tar.gz

demathpy-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Misekai
+
+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.

demathpy-0.1.0/PKG-INFO

@@ -0,0 +1,160 @@
+Metadata-Version: 2.4
+Name: demathpy
+Version: 0.1.0
+Summary: PDE/ODE math backend
+Author: Misekai
+Author-email: Misekai <mcore-us@misekai.net>
+License-Expression: MIT
+License-File: LICENSE
+Requires-Dist: numpy>=1.24.0
+Requires-Dist: sympy>=1.12.0
+Requires-Dist: typing>=3.10.0.0
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# Demathpy
+
+A Python library for parsing and safely evaluating symbolic Ordinary and Partial Differential Equations (ODEs/PDEs) on numerical grids.
+
+This repository provides:
+- A class-based `PDE` solver (`from demathpy import PDE`) for running simulations.
+- A lightweight **symbol normalizer** that converts human-readable mathematical notation into valid Python expressions.
+- Equation-based Boundary Conditions and Initial Conditions.
+- Built-in support for common differential operators and vector calculus notation using Finite Differences.
+
+### Key Features
+
+#### 1. The PDE Class
+
+The core of the library is the `PDE` class. It manages the grid state, parsing, and time-stepping.
+
+```python
+from demathpy import PDE
+import numpy as np
+
+# Define a Heat Equation: du/dt = Laplacian(u)
+p = PDE("du/dt = lap(u)", space_axis=["x", "y"])
+
+# Configure the grid
+p.init_grid(width=100, height=100, dx=0.5)
+
+# Set Initial Conditions using equations
+p.initial = ["u = exp(-(x-25)**2 - (y-25)**2)"]
+p.set_initial_state()
+
+# Set Boundary Conditions using equations
+# Format: "axis(coord) = value" or "axis=coord = value"
+p.boundry = [
+    "x=0 = 1.0",     # Left boundary (x=0) is fixed at 1.0
+    "x=100 = 0.0",   # Right boundary (x=100) is fixed at 0.0
+    "y=0 = 0.0",     # Bottom boundary is 0.0
+    "periodic"       # Other unset boundaries (y=100) default to periodic or 0
+]
+
+# Run simulation
+for _ in range(100):
+    p.step(dt=0.01)
+
+print(p.u.mean())
+```
+
+#### 2. Equation-Based Configuration
+
+You can configure boundaries and initial states using string equations instead of manual array manipulation.
+
+**Boundary Conditions (`p.boundry` list):**
+- **Dirichlet:** `x=0 = 1.0` (Fixes value at boundary)
+- **Neumann:** `dx(u) = 0` (Not fully exposed yet, currently defaults to Dirichlet logic if value provided).
+- **Periodic:** Use `periodic` keyword or leave empty for default periodic behavior (if implemented).
+
+**Initial Conditions (`p.initial` list):**
+- **Scalar:** `u = sin(x) * cos(y)`
+- **Vector Components:** `ux = 1.0`, `uy = 0.0` (if `p.u_shape = ["ux", "uy"]`)
+
+#### 3. Vector Fields
+
+The solver supports vector-valued PDEs (e.g., Navier-Stokes, Reaction-Diffusion systems).
+
+```python
+# 2D Advection: du/dt = - (u · ∇) u
+p = PDE("du/dt = -advect(u, u)", space_axis=["x", "y"])
+p.u_shape = ["ux", "uy"] # Define component names
+p.init_grid(width=50, height=50, dx=1.0)
+
+# Initialize Vortex
+p.initial = [
+    "ux = -sin(y)",
+    "uy = sin(x)"
+]
+p.set_initial_state()
+```
+
+### Supported Operators
+
+The parser recognizes and maps these to NumPy finite difference functions:
+
+- **Derivatives:** `du/dt`, `dx(u)`, `dy(u)`, `dz(u)`
+- **Second Derivatives:** `dxx(u)`, `dzz(u)`
+- **Laplacian:** `lap(u)` or `∇²u`
+- **Gradient:** `grad(u)` or `∇u` (Returns vector)
+- **Divergence:** `div(u)` or `∇·u` (Expects vector input)
+- **Advection:** `advect(velocity, field)` -> `(velocity · ∇) field`
+- **Math Functions:** `sin, cos, exp, log, abs, sqrt, tanh` ...
+
+### Symbol Normalization
+
+The parser supports Unicode and mathematical shorthand:
+- `α, β, γ` → `alpha, beta, gamma`
+- `u²` → `u**2`
+- `|u|` → `abs(u)`
+
+### Workflow & Visualization
+
+To integrate `Demathpy` into visualization software or interactive notebooks, you can use the `get_grid()` method to probe the field dynamics without advancing the simulation time.
+
+#### Visualization Step-by-Step
+
+1.  **Initialize**:
+    ```python
+    p = PDE("du/dt = lap(u) - u**3 + u", space_axis=["x", "y"])
+    p.init_grid(width=20, height=20, dx=0.5)
+    p.initial = ["u = 0.1 * sin(x)"] 
+    p.boundry = ["periodic"]
+    p.set_initial_state()
+    ```
+
+2.  **Probe the Vector Field (du/dt)**:
+    Use `get_grid(dt=0)` to get the instantaneous rate of change. This is useful for visualizing flow fields or phase plots.
+    ```python
+    # Get Rate of Change (RHS of PDE)
+    du_dt = p.get_grid(dt=0)
+    
+    # Or calculate the hypothetical next step delta
+    delta_u = p.get_grid(dt=0.01)
+    ```
+
+3.  **Predict on Arbitrary States**:
+    You can evaluate the PDE on a hypothetical state `u_test` without updating the solver's internal state. This is useful for drawing vector fields in phase space.
+    ```python
+    # Create a test state
+    test_u = np.sin(p.u) 
+    
+    # Calculate how the PDE would evolve this state
+    # Returns the rate of change for the test state
+    response = p.get_grid(u_state=test_u, dt=0)
+    ```
+
+4.  **Run Simulation Loops**:
+    ```python
+    import matplotlib.pyplot as plt
+    
+    for i in range(100):
+        p.step(dt=0.01)
+        if i % 10 == 0:
+            plt.imshow(p.u) # Visualization logic
+            # plt.show()
+    ```
+
+### License
+
+MIT

demathpy-0.1.0/README.md

@@ -0,0 +1,146 @@
+# Demathpy
+
+A Python library for parsing and safely evaluating symbolic Ordinary and Partial Differential Equations (ODEs/PDEs) on numerical grids.
+
+This repository provides:
+- A class-based `PDE` solver (`from demathpy import PDE`) for running simulations.
+- A lightweight **symbol normalizer** that converts human-readable mathematical notation into valid Python expressions.
+- Equation-based Boundary Conditions and Initial Conditions.
+- Built-in support for common differential operators and vector calculus notation using Finite Differences.
+
+### Key Features
+
+#### 1. The PDE Class
+
+The core of the library is the `PDE` class. It manages the grid state, parsing, and time-stepping.
+
+```python
+from demathpy import PDE
+import numpy as np
+
+# Define a Heat Equation: du/dt = Laplacian(u)
+p = PDE("du/dt = lap(u)", space_axis=["x", "y"])
+
+# Configure the grid
+p.init_grid(width=100, height=100, dx=0.5)
+
+# Set Initial Conditions using equations
+p.initial = ["u = exp(-(x-25)**2 - (y-25)**2)"]
+p.set_initial_state()
+
+# Set Boundary Conditions using equations
+# Format: "axis(coord) = value" or "axis=coord = value"
+p.boundry = [
+    "x=0 = 1.0",     # Left boundary (x=0) is fixed at 1.0
+    "x=100 = 0.0",   # Right boundary (x=100) is fixed at 0.0
+    "y=0 = 0.0",     # Bottom boundary is 0.0
+    "periodic"       # Other unset boundaries (y=100) default to periodic or 0
+]
+
+# Run simulation
+for _ in range(100):
+    p.step(dt=0.01)
+
+print(p.u.mean())
+```
+
+#### 2. Equation-Based Configuration
+
+You can configure boundaries and initial states using string equations instead of manual array manipulation.
+
+**Boundary Conditions (`p.boundry` list):**
+- **Dirichlet:** `x=0 = 1.0` (Fixes value at boundary)
+- **Neumann:** `dx(u) = 0` (Not fully exposed yet, currently defaults to Dirichlet logic if value provided).
+- **Periodic:** Use `periodic` keyword or leave empty for default periodic behavior (if implemented).
+
+**Initial Conditions (`p.initial` list):**
+- **Scalar:** `u = sin(x) * cos(y)`
+- **Vector Components:** `ux = 1.0`, `uy = 0.0` (if `p.u_shape = ["ux", "uy"]`)
+
+#### 3. Vector Fields
+
+The solver supports vector-valued PDEs (e.g., Navier-Stokes, Reaction-Diffusion systems).
+
+```python
+# 2D Advection: du/dt = - (u · ∇) u
+p = PDE("du/dt = -advect(u, u)", space_axis=["x", "y"])
+p.u_shape = ["ux", "uy"] # Define component names
+p.init_grid(width=50, height=50, dx=1.0)
+
+# Initialize Vortex
+p.initial = [
+    "ux = -sin(y)",
+    "uy = sin(x)"
+]
+p.set_initial_state()
+```
+
+### Supported Operators
+
+The parser recognizes and maps these to NumPy finite difference functions:
+
+- **Derivatives:** `du/dt`, `dx(u)`, `dy(u)`, `dz(u)`
+- **Second Derivatives:** `dxx(u)`, `dzz(u)`
+- **Laplacian:** `lap(u)` or `∇²u`
+- **Gradient:** `grad(u)` or `∇u` (Returns vector)
+- **Divergence:** `div(u)` or `∇·u` (Expects vector input)
+- **Advection:** `advect(velocity, field)` -> `(velocity · ∇) field`
+- **Math Functions:** `sin, cos, exp, log, abs, sqrt, tanh` ...
+
+### Symbol Normalization
+
+The parser supports Unicode and mathematical shorthand:
+- `α, β, γ` → `alpha, beta, gamma`
+- `u²` → `u**2`
+- `|u|` → `abs(u)`
+
+### Workflow & Visualization
+
+To integrate `Demathpy` into visualization software or interactive notebooks, you can use the `get_grid()` method to probe the field dynamics without advancing the simulation time.
+
+#### Visualization Step-by-Step
+
+1.  **Initialize**:
+    ```python
+    p = PDE("du/dt = lap(u) - u**3 + u", space_axis=["x", "y"])
+    p.init_grid(width=20, height=20, dx=0.5)
+    p.initial = ["u = 0.1 * sin(x)"] 
+    p.boundry = ["periodic"]
+    p.set_initial_state()
+    ```
+
+2.  **Probe the Vector Field (du/dt)**:
+    Use `get_grid(dt=0)` to get the instantaneous rate of change. This is useful for visualizing flow fields or phase plots.
+    ```python
+    # Get Rate of Change (RHS of PDE)
+    du_dt = p.get_grid(dt=0)
+    
+    # Or calculate the hypothetical next step delta
+    delta_u = p.get_grid(dt=0.01)
+    ```
+
+3.  **Predict on Arbitrary States**:
+    You can evaluate the PDE on a hypothetical state `u_test` without updating the solver's internal state. This is useful for drawing vector fields in phase space.
+    ```python
+    # Create a test state
+    test_u = np.sin(p.u) 
+    
+    # Calculate how the PDE would evolve this state
+    # Returns the rate of change for the test state
+    response = p.get_grid(u_state=test_u, dt=0)
+    ```
+
+4.  **Run Simulation Loops**:
+    ```python
+    import matplotlib.pyplot as plt
+    
+    for i in range(100):
+        p.step(dt=0.01)
+        if i % 10 == 0:
+            plt.imshow(p.u) # Visualization logic
+            # plt.show()
+    ```
+
+### License
+
+MIT

demathpy-0.1.0/pyproject.toml

@@ -0,0 +1,29 @@
+
+[project]
+name = "demathpy"
+version = "0.1.0"
+authors = [
+  { name="Misekai", email="mcore-us@misekai.net" },
+]
+description = "PDE/ODE math backend"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "numpy>=1.24.0",
+    "sympy>=1.12.0",
+    "typing>=3.10.0.0",
+]
+
+
+license = "MIT"
+license-files = ["LICEN[CS]E*"]
+
+[build-system]
+requires = ["uv_build >= 0.9.26, <0.10.0"]
+build-backend = "uv_build"
+
+[dependency-groups]
+dev = [
+    "pytest>=9.0.2",
+]
+

demathpy-0.1.0/src/demathpy/__init__.py

@@ -0,0 +1,23 @@
+"""demathpy: PDE/ODE math backend for rde-core."""
+
+from .symbols import normalize_symbols, normalize_lhs
+from .pde import (
+    PDE,
+    normalize_pde,
+    init_grid,
+    parse_pde,
+    step_pdes,
+)
+from .ode import robust_parse, parse_odes_to_function
+
+__all__ = [
+    "PDE",
+    "normalize_symbols",
+    "normalize_lhs",
+    "normalize_pde",
+    "init_grid",
+    "parse_pde",
+    "step_pdes",
+    "robust_parse",
+    "parse_odes_to_function",
+]

demathpy-0.1.0/src/demathpy/ode.py

@@ -0,0 +1,131 @@
+import json
+import re
+import sympy
+import numpy as np
+from sympy.parsing.sympy_parser import parse_expr, standard_transformations, implicit_multiplication_application, convert_xor
+
+
+def _convert_ternary(expr: str) -> str:
+    """
+    Convert a single C-style ternary (cond ? a : b) into SymPy Piecewise.
+    Supports one level (no nesting).
+    """
+    if "?" not in expr or ":" not in expr:
+        return expr
+
+    # naive split for single ternary
+    # pattern: <cond> ? <a> : <b>
+    parts = expr.split("?")
+    if len(parts) != 2:
+        return expr
+    cond = parts[0].strip()
+    rest = parts[1]
+    if ":" not in rest:
+        return expr
+    a, b = rest.split(":", 1)
+    a = a.strip()
+    b = b.strip()
+    return f"Piecewise(({a}, {cond}), ({b}, True))"
+
+
+def robust_parse(expr_str):
+    """
+    Parses a string into a SymPy expression with relaxed syntax rules:
+    - Implicit multiplication (5x -> 5*x)
+    - Caret for power (x^2 -> x**2)
+    - Aliases 'y' to 'z' for 2D convenience
+    """
+    if not isinstance(expr_str, str):
+        return sympy.sympify(expr_str) 
+        
+    transformations = (standard_transformations + (implicit_multiplication_application, convert_xor))
+    
+    # Define symbols and alias y -> z
+    x, z, vx, vz, t, pid = sympy.symbols('x z vx vz t id')
+    local_dict = {
+        'x': x, 'z': z, 'y': z, 'vx': vx, 'vz': vz, 't': t, 'id': pid,
+        'pi': sympy.pi, 'e': sympy.E
+    }
+
+    # Ensure common functions are recognized (Abs not abs)
+    local_dict.update({
+        'sin': sympy.sin,
+        'cos': sympy.cos,
+        'tan': sympy.tan,
+        'exp': sympy.exp,
+        'sqrt': sympy.sqrt,
+        'log': sympy.log,
+        'abs': sympy.Abs,
+        'Abs': sympy.Abs,
+        'Piecewise': sympy.Piecewise,
+    })
+
+    try:
+        pre = _convert_ternary(expr_str)
+        return parse_expr(pre, transformations=transformations, local_dict=local_dict)
+    except Exception:
+        # Fallback
+        return sympy.sympify(expr_str, locals=local_dict)
+
+
+def parse_odes_to_function(ode_json_str):
+    """
+    Parses a JSON string of ODEs and returns a dynamic update function.
+    """
+    try:
+        if isinstance(ode_json_str, str):
+            odes = json.loads(ode_json_str)
+        else:
+            odes = ode_json_str
+    except json.JSONDecodeError as e:
+        print(f"Failed to decode JSON from LLM: {e}")
+        return None
+
+    # Define standard symbols
+    x, z, vx, vz, t = sympy.symbols('x z vx vz t')
+    
+    deriv_map = {}
+    keys = ['dx', 'dz', 'dvx', 'dvz']
+    
+    for key in keys:
+        expr_str = odes.get(key, "0")
+        try:
+            # Parse the expression safely using robust parser
+            expr = robust_parse(str(expr_str))
+            
+            # Create a localized function
+            # Arguments match the order we will call them
+            func = sympy.lambdify((x, z, vx, vz, t), expr, modules=['numpy', 'math'])
+            deriv_map[key] = func
+        except Exception as e:
+            print(f"Error parsing expression for {key}: {e}")
+            return None
+
+    def dynamics(particle, dt):
+        # Current state
+        cx, cz, cvx, cvz = particle.x, particle.z, particle.vx, particle.vz
+        # We assume particle might track time, or we just pass 0 if autonomous
+        ct = getattr(particle, 'time', 0.0)
+        
+        try:
+            # Calculate derivatives
+            val_dx = deriv_map['dx'](cx, cz, cvx, cvz, ct)
+            val_dz = deriv_map['dz'](cx, cz, cvx, cvz, ct)
+            val_dvx = deriv_map['dvx'](cx, cz, cvx, cvz, ct)
+            val_dvz = deriv_map['dvz'](cx, cz, cvx, cvz, ct)
+            
+            # Simple Euler Integration
+            particle.x += float(val_dx) * dt
+            particle.z += float(val_dz) * dt
+            particle.vx += float(val_dvx) * dt
+            particle.vz += float(val_dvz) * dt
+            
+            # Update time if tracked
+            if hasattr(particle, 'time'):
+                particle.time += dt
+                
+        except Exception as e:
+            # Prevent crashing the renderer on math errors (e.g. div by zero)
+            print(f"Runtime error in dynamics: {e}")
+
+    return dynamics