demathpy 0.0.2__py3-none-any.whl → 0.1.1__py3-none-any.whl

demathpy/symbols.py

@@ -168,6 +168,24 @@ REGEX_RULES = [
     # divergence shorthand: ∇ * u or ∇ * (u)
     (r"∇\s*\*\s*\(([^\)]*)\)", r"div(\1)"),
     (r"∇\s*\*\s*([a-zA-Z_][a-zA-Z0-9_]*)", r"div(\1)"),
+    # advection operator: (u · ∇) v -> advect(u, v)
+    # Match (u · ∇) or (u * ∇) followed by v or (v)
+    # Handle both · (before replacement) and * (after replacement if regex runs late)?
+    # actually SYMBOL_MAP runs later or earlier?
+    # In normalize_symbols, SYMBOL_MAP runs BEFORE regex rules.
+    # So · becomes *.
+    # But wait, in code:
+    # 1. replace greek
+    # 2. replace ∇·, ∇(
+    # 3. balanced paren calls
+    # 4. SYMBOL_MAP replacement (· -> *)
+    # 5. REGEX_RULES
+    # So we only need to match * for dot product.
+    
+    # (u * ∇) v -> advect(u, v)
+    (r"\(\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*\*\s*∇\s*\)\s*([a-zA-Z_][a-zA-Z0-9_]*)", r"advect(\1, \2)"),
+    (r"\(\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*\*\s*∇\s*\)\s*\(([^\)]*)\)", r"advect(\1, \2)"),
+
     # gradient: ∇(u)
     (r"∇\s*\(([^\)]*)\)", r"grad(\1)"),
     # gradient magnitude |∇u|^2
@@ -375,8 +393,8 @@ def normalize_symbols(expr: str) -> str:
             "arcsin", "arccos", "arctan",
             "exp", "sqrt",
             "log", "log10", "log2",
-            "abs", "sech", "sign",
-            "lap", "dx", "dz", "dxx", "dzz", "grad", "div", "gradmag", "gradl1", "pos",
+            "abs", "sech", "sign", "step", "heaviside",
+            "lap", "dx", "dz", "dxx", "dzz", "grad", "div", "advect", "gradmag", "gradl1", "pos",
         }:
             return f"{name}("
         return f"{name}*("

demathpy-0.1.1.dist-info/METADATA

@@ -0,0 +1,207 @@
+Metadata-Version: 2.4
+Name: demathpy
+Version: 0.1.1
+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()
+    ```
+
+### The ODE Class
+
+Demathpy also efficiently solves Ordinary Differential Equations (ODEs) where the state depends only on time $t$. The API is identical to the PDE class.
+
+```python
+from demathpy import ODE
+
+# 1. EXPONENTIAL DECAY
+# dy/dt = -y
+o = ODE("dy/dt = -y", u_shape=["y"])
+o.initial = ["y = 1.0"] 
+o.init_state(shape=(1,)) # scalar system
+o.set_initial_state()
+
+for _ in range(100):
+    o.step(dt=0.01) 
+print(o.u) # Should be close to exp(-1)
+
+# 2. VECTOR SYSTEMS (Predator-Prey)
+# du/dt = u - u*v
+# dv/dt = u*v - v
+pp = ODE("du/dt = [u[0] - u[0]*u[1], u[0]*u[1] - u[1]]", u_shape=["u", "v"])
+pp.initial = ["u = 1.1", "v = 1.0"]
+pp.init_state(shape=(1,)) # Single ecosystem
+pp.set_initial_state()
+
+pp.step(dt=0.1)
+
+# 3. BATCHED EXECUTION
+# Simulating 1000 identical particles with different initial conditions
+particles = ODE("dx/dt = -x + noise") # noise not impl by default but external vars work
+# Or just decay
+batch = ODE("dy/dt = -y")
+batch.init_state(shape=(1000,)) # 1000 systems
+# Set random initial states directly (or use equation if supported)
+import numpy as np
+batch.u[:] = np.random.rand(1000)
+
+batch.step(0.1)
+```
+
+**Key ODE Features:**
+- **Equation Parsing:** Supports `dy/dt`, `d^2y/dt^2`, vector syntax `[a, b]`.
+- **Initialization:** Use `init_state(shape=...)` where shape defines the batch size (independent systems).
+- **Probing:** `get_grid(u_state=..., dt=0)` works exactly like PDE for generating phase portraits (return vector field at state).
+- **Functions:** Includes `sin, cos, exp, step, heaviside, sign, abs` ...
+
+### License
+
+MIT

demathpy-0.1.1.dist-info/RECORD

@@ -0,0 +1,8 @@
+demathpy/__init__.py,sha256=gtvKvQKWns_OkAb9uyPmX8jIys0o62ccE_lMbi1_YQE,404
+demathpy/ode.py,sha256=BTAqBdLP3otNi0zjOKA5eEGrJWlP0rK8n2uuYE8wGIk,12869
+demathpy/pde.py,sha256=v8tMQGKyelmYaQI4mMJmge4WW8KK6NGTCmZlmZ8XI-I,31788
+demathpy/symbols.py,sha256=ZJDL31vo8Ei3_MsffAO0efJsBaVMzgyGFv1Vva4iceg,13776
+demathpy-0.1.1.dist-info/licenses/LICENSE,sha256=Vofo4OGPZaOEnCixsvF2MaZSGdpDI4uVMm9GNEjSGBM,1064
+demathpy-0.1.1.dist-info/WHEEL,sha256=5DEXXimM34_d4Gx1AuF9ysMr1_maoEtGKjaILM3s4w4,80
+demathpy-0.1.1.dist-info/METADATA,sha256=imE4ZojXX-L91VXpFdC-8AyPOXu01SLinC9ayHxD5dk,6574
+demathpy-0.1.1.dist-info/RECORD,,

{demathpy-0.0.2.dist-info → demathpy-0.1.1.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: uv 0.9.27
+Generator: uv 0.9.29
 Root-Is-Purelib: true
 Tag: py3-none-any

demathpy-0.0.2.dist-info/METADATA

@@ -1,106 +0,0 @@
-Metadata-Version: 2.4
-Name: demathpy
-Version: 0.0.2
-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 lightweight **symbol normalizer** that converts human-readable mathematical notation into valid Python expressions.
-- A **secure evaluation engine** that evaluates PDE/ODE right-hand sides on NumPy grids without using raw `eval` on untrusted input.
-- Built-in support for common differential operators and vector calculus notation.
-
-### Key Features
-
-#### 1. Symbol Normalization
-
-The parser supports Unicode and mathematical shorthand, including:
-
-- Greek letters: `α, β, γ, λ, ε, φ, θ` → `alpha, beta, gamma, lam, epsilon, phi, theta`
-- Powers: `u², v³` → `u**2, v**3`
-- Implicit multiplication:  
-  - `αu` → `alpha*u`  
-  - `2u` → `2*u`  
-  - `(u+1)(v+1)` → `(u+1)*(v+1)`
-- Absolute values: `|u|` → `abs(u)`
-- Common functions:  
-  `sin, cos, tan, exp, log, tanh, sech, sign, sqrt`
-
-#### 2. Differential Operator Support
-
-The parser recognizes and evaluates:
-
-- First derivatives:
-  - `du/dt`, `u_t`
-- Second derivatives:
-  - `dxx(u)`, `dzz(u)`
-- Laplacian:
-  - `∇²u`, `lap(u)`
-- Gradient:
-  - `∇u`, `grad(u)`
-- Divergence:
-  - `∇·(A)`, `div(A)`
-
-These are mapped to finite-difference operators implemented in NumPy.
-
-#### 3. PDE / ODE Parsing
-
-The library provides:
-
-- `parse_pde(equation: str)`  
-  Parses a PDE string and returns `(lhs_variable, rhs_expression)`.
-
-- `evaluate_rhs(rhs: str, grids: dict, constants: dict, grid_dx: float)`  
-  Safely evaluates the right-hand side on NumPy arrays representing fields and parameters.
-
-Supports equations such as:
-
-```text
-∂T/∂t = α ∇²T - σ T
-u_t = D dxx(u) + f(u)
-∂φ/∂t = ∇·((1 + T²) ∇φ)
-```
-#### 4. Secure Evaluation Environment
-Only a restricted set of functions and operators are exposed.
-No access to Python builtins, file I/O, or unsafe functions.
-All variables must come from:
-grids: NumPy arrays for fields (u, T, phi, etc.)
-constants: scalar parameters (alpha, beta, lambda, etc.)
-#### 5. Coordinate-Aware PDEs
-The evaluator automatically provides spatial coordinate grids:
-x, z as NumPy arrays derived from grid shape and spacing.
-This enables anisotropic and spatially varying coefficients such as:
-``` α x dxx(T) + α z dzz(T)```
-Typical Use:
-
-```text 
-from pde import parse_pde, evaluate_rhs
-
-lhs, rhs = parse_pde("∂T/∂t = α ∇²T - σ T")
-
-result = evaluate_rhs(
-    rhs,
-    grids={"T": T_grid},
-    constants={"alpha": 0.1, "sigma": 0.01},
-    grid_dx=0.01
-)
-```
-
-#### 6. Purpose
-This project is intended as a safe mathematical expression parser for:
-Scientific computing
-PDE/ODE solvers
-Physics and engineering simulations
-Educational or sandboxed equation evaluation

demathpy-0.0.2.dist-info/RECORD

@@ -1,8 +0,0 @@
-demathpy/__init__.py,sha256=M9USmv1V8FoXhHVFtOlwO8zyEA1cafpubvBEDLQ4eXw,722
-demathpy/ode.py,sha256=3SgeiYbHUov9NtrKCOhCo2I4DFLLdh5iIqkhPxwt254,4188
-demathpy/pde.py,sha256=TjX9ICiJOO54_CPRZljRdOgMCuHwXFs-eaXDdM4O1hQ,13645
-demathpy/symbols.py,sha256=fYCJ8ja4tgkMg1BlSGiV4bHt7i9yXSI57F8M-8nl0Qg,12957
-demathpy-0.0.2.dist-info/licenses/LICENSE,sha256=Vofo4OGPZaOEnCixsvF2MaZSGdpDI4uVMm9GNEjSGBM,1064
-demathpy-0.0.2.dist-info/WHEEL,sha256=e_m4S054HL0hyR3CpOk-b7Q7fDX6BuFkgL5OjAExXas,80
-demathpy-0.0.2.dist-info/METADATA,sha256=kD-ZEpceKifIhUV2rnsRavX_hKgITfhSZWraB0Z5Io8,3118
-demathpy-0.0.2.dist-info/RECORD,,