demathpy 0.0.1__py3-none-any.whl → 0.1.0__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
@@ -287,25 +305,40 @@ def normalize_symbols(expr: str) -> str:
         "omicron|pi|rho|sigma|tau|upsilon|phi|chi|psi|omega"
     )
     fn_words = "sin|cos|tan|sinh|cosh|tanh|exp|log|log10|log2|sqrt|abs|sech|sign"
+    # Use word boundary \b to avoid matching inside words
     expr = re.sub(rf"\b({greek_words})(?=({fn_words})\b)", r"\1*", expr)
-    # Greek word directly followed by a single-letter variable (e.g., beta u)
-        # Greek word directly followed by a single-letter variable (e.g., beta u) or concatenated (betau).
+    # Greek word directly followed by a single-letter variable (e.g., beta u) or concatenated (betau).
     # BUT do not split axis-suffixed coefficients like alphax/alphaz (common in anisotropic diffusion terms).
     _axis_coeffs = {
         "alphax", "alphaz", "betax", "betaz", "gammax", "gammaz", "deltax", "deltaz",
         "sigmax", "sigmaz", "thetax", "thetaz", "kappax", "kappaz", "lambdax", "lambdaz",
         "rhox", "rhoz", "mux", "muz", "nux", "nuz",
+        # Also protect eps/epsilon from being split
+        "epsilon", "eps",
     }
 
     def _split_greek_letter_var(m: re.Match) -> str:
         greek = m.group(1)
         letter = m.group(2)
         combined = f"{greek}{letter}"
+        # Don't split if this creates a known coefficient (e.g., alphax, sigmaz)
         if combined in _axis_coeffs:
             return combined
+        # Don't split if combined is the start of a greek word (to avoid "epsi*lon" from "epsilon")
+        # Check if any greek word starts with the combined string
+        all_greek_words = {"alpha", "beta", "gamma", "delta", "epsilon", "zeta", "eta", "theta", 
+                          "iota", "kappa", "lam", "mu", "nu", "xi", "omicron", "pi", "rho", 
+                          "sigma", "tau", "upsilon", "phi", "chi", "psi", "omega"}
+        for gw in all_greek_words:
+            if gw.startswith(combined) and len(gw) > len(combined):
+                # combined is a prefix of a longer greek word, so don't split
+                return combined
+        # Otherwise, insert multiplication: betau -> beta*u
         return f"{greek}*{letter}"
 
-    expr = re.sub(rf"({greek_words})([A-Za-z])", _split_greek_letter_var, expr)
+    # Only match at word boundaries to avoid splitting within words like 'epsilon'
+    # Use lookahead to detect when a greek word is followed by a single letter that starts a new token
+    expr = re.sub(rf"\b({greek_words})([A-Za-z])(?=([^a-zA-Z]|$))", _split_greek_letter_var, expr)
 
     # Absolute value for variables/parentheses
     expr = re.sub(r"\|\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*\|", r"abs(\1)", expr)
@@ -361,7 +394,7 @@ def normalize_symbols(expr: str) -> str:
             "exp", "sqrt",
             "log", "log10", "log2",
             "abs", "sech", "sign",
-            "lap", "dx", "dz", "dxx", "dzz", "grad", "div", "gradmag", "gradl1", "pos",
+            "lap", "dx", "dz", "dxx", "dzz", "grad", "div", "advect", "gradmag", "gradl1", "pos",
         }:
             return f"{name}("
         return f"{name}*("

demathpy-0.1.0.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,8 @@
+demathpy/__init__.py,sha256=O2m_YqVOiPaPVC7b9jJdObU9mFmPVZuvIvHf5JY2bKQ,448
+demathpy/ode.py,sha256=3SgeiYbHUov9NtrKCOhCo2I4DFLLdh5iIqkhPxwt254,4188
+demathpy/pde.py,sha256=v8tMQGKyelmYaQI4mMJmge4WW8KK6NGTCmZlmZ8XI-I,31788
+demathpy/symbols.py,sha256=kdONgSB_-9jL6DEGx9GyJMorYY1wTOZ6C-GV18_rMd0,13755
+demathpy-0.1.0.dist-info/licenses/LICENSE,sha256=Vofo4OGPZaOEnCixsvF2MaZSGdpDI4uVMm9GNEjSGBM,1064
+demathpy-0.1.0.dist-info/WHEEL,sha256=fAguSjoiATBe7TNBkJwOjyL1Tt4wwiaQGtNtjRPNMQA,80
+demathpy-0.1.0.dist-info/METADATA,sha256=AUpR7HK1cHuDJMWQNYubUs6VN-bnMCHcB60HprMWdLc,5018
+demathpy-0.1.0.dist-info/RECORD,,

{demathpy-0.0.1.dist-info → demathpy-0.1.0.dist-info}/WHEEL

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

demathpy-0.0.1.dist-info/METADATA

@@ -1,106 +0,0 @@
-Metadata-Version: 2.4
-Name: demathpy
-Version: 0.0.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 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.1.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=LwwqdmvDX_-G2T9t885sPdI4G7bSzMY6d07-uwuzyl4,11904
-demathpy-0.0.1.dist-info/licenses/LICENSE,sha256=Vofo4OGPZaOEnCixsvF2MaZSGdpDI4uVMm9GNEjSGBM,1064
-demathpy-0.0.1.dist-info/WHEEL,sha256=e_m4S054HL0hyR3CpOk-b7Q7fDX6BuFkgL5OjAExXas,80
-demathpy-0.0.1.dist-info/METADATA,sha256=wK14apREWoyXvKuekx-jcOahaG8gOk4IhmIdXj4P7P0,3118
-demathpy-0.0.1.dist-info/RECORD,,