pyphysica 0.1.0__tar.gz

pyphysica-0.1.0/LICENSE

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

pyphysica-0.1.0/MANIFEST.in

@@ -0,0 +1,4 @@
+include LICENSE
+include README.md
+recursive-include examples *.py
+recursive-include tests *.py

pyphysica-0.1.0/PKG-INFO

@@ -0,0 +1,161 @@
+Metadata-Version: 2.4
+Name: pyphysica
+Version: 0.1.0
+Summary: A symbolic + numeric physics DSL: decorator-based forces, time-varying vectors, and sympy-derived equations of motion.
+Author: Rohan Hariharan
+License: MIT
+Project-URL: Homepage, https://github.com/rohanhariharan/pyphysica
+Project-URL: Repository, https://github.com/rohanhariharan/pyphysica
+Project-URL: Issues, https://github.com/rohanhariharan/pyphysica/issues
+Keywords: physics,simulation,sympy,symbolic,cas,dsl,mechanics
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Education
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Physics
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: sympy
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Dynamic: license-file
+
+# pyphysica
+
+[![PyPI](https://img.shields.io/pypi/v/pyphysica.svg)](https://pypi.org/project/pyphysica/)
+[![Python versions](https://img.shields.io/pypi/pyversions/pyphysica.svg)](https://pypi.org/project/pyphysica/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+
+A symbolic + numeric physics DSL for Python. Declare forces as class attributes,
+let `pyphysica` integrate them numerically — or derive the equations of motion
+symbolically with [SymPy](https://www.sympy.org/).
+
+```python
+from physica import Object2, Vector2, continuous, update
+
+ball = Object2("ball", mass=0.45, position=Vector2(0, 10), velocity=Vector2(5, 0))
+
+@continuous(ball)
+class Gravity:
+    gravity = Vector2(0, -9.81)
+
+@update(ball)
+def physics(obj, dt):
+    obj.integrate(dt)
+
+for _ in range(100):
+    physics(ball, 0.016)
+
+print(ball.position)          # <8.0, -2.5568>
+print(ball.kinetic_energy())
+```
+
+## Install
+
+```sh
+pip install pyphysica
+```
+
+From source:
+
+```sh
+git clone https://github.com/rohanhariharan/pyphysica
+cd pyphysica
+pip install -e ".[dev]"
+```
+
+## What it does
+
+**Decorator-based forces.** Annotate a class with `@continuous(obj)` to register
+each `Vector2` attribute as a per-step force, or `@impulse(obj)` for a one-shot
+impulse (`Δv = J/m`).
+
+**Time-varying forces.** `TimeVector` lets a force change over time, either
+symbolically in `T` or as a Python callable:
+
+```python
+from physica import TimeVector, T
+
+@continuous(obj)
+class Engine:
+    drive = TimeVector.of(lambda t: Vector2(4 * sp.sin(t), 0))   # callable
+    thrust = TimeVector(0, 120.0 - 3 * T)                        # symbolic in T
+```
+
+**Symbolic equations of motion.** Since forces may be expressions in `T`,
+`Object2` can return them as SymPy:
+
+```python
+ax, ay = obj.equation_of_motion()      # expressions in T
+ax, ay = obj.acceleration_func()       # T-bound Funcs
+vy     = obj.velocity_func()           # integrate once from rest
+y      = obj.position_func()           # integrate twice from rest
+sol    = obj.closed_form()             # dsolve, zero initial conditions
+```
+
+Multi-body systems:
+
+```python
+from physica import combine, describe_system
+
+print(describe_system([rocket, booster]))
+system = combine([rocket, booster])    # total mass, summed net force, per-body accel
+```
+
+**Symbolic math (`Func`/`Lim`).** A thin, ergonomic wrapper over SymPy:
+
+```python
+from physica import Func, Lim, x, T
+import sympy as sp
+
+f = Func(x**2 - 1)
+f(3)            # 8
+f[1]            # derivative  -> 2*x
+f[-1]           # antiderivative
+f[[0, 1]]       # definite integral
+(f @ Func(x + 1))     # composition
+Lim(sp.sin(x)/x, x, 0)   # 1
+
+g = Func(3 * T + 1, var=T)   # variable-aware: defaults to x
+```
+
+**Vectors and more.** `Vector2`, `Vector3`, `Quaternion`, and `Matrix` round out
+the math layer.
+
+## Example
+
+See [`examples/example_physics.py`](examples/example_physics.py) for seven
+worked examples — projectile with wind and an impulsive kick, a time-varying
+drive, multi-object systems, `simulate()` history, `Func` bootstrap over derived
+equations, and both the exact and small-angle pendulum.
+
+```sh
+python examples/example_physics.py
+```
+
+## Tests
+
+```sh
+pip install -e ".[dev]"
+pytest
+```
+
+## Physics notes
+
+- Integration is semi-implicit Euler, which introduces `O(dt)` energy drift.
+  Halving the timestep halves the drift.
+- `small-angle` checks against the analytic SHM solution agree to `< 1e-3`.
+- Equations of motion are derived from Newton's second law: `a = F_net / m`.
+
+## License
+
+MIT

pyphysica-0.1.0/README.md

@@ -0,0 +1,130 @@
+# pyphysica
+
+[![PyPI](https://img.shields.io/pypi/v/pyphysica.svg)](https://pypi.org/project/pyphysica/)
+[![Python versions](https://img.shields.io/pypi/pyversions/pyphysica.svg)](https://pypi.org/project/pyphysica/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+
+A symbolic + numeric physics DSL for Python. Declare forces as class attributes,
+let `pyphysica` integrate them numerically — or derive the equations of motion
+symbolically with [SymPy](https://www.sympy.org/).
+
+```python
+from physica import Object2, Vector2, continuous, update
+
+ball = Object2("ball", mass=0.45, position=Vector2(0, 10), velocity=Vector2(5, 0))
+
+@continuous(ball)
+class Gravity:
+    gravity = Vector2(0, -9.81)
+
+@update(ball)
+def physics(obj, dt):
+    obj.integrate(dt)
+
+for _ in range(100):
+    physics(ball, 0.016)
+
+print(ball.position)          # <8.0, -2.5568>
+print(ball.kinetic_energy())
+```
+
+## Install
+
+```sh
+pip install pyphysica
+```
+
+From source:
+
+```sh
+git clone https://github.com/rohanhariharan/pyphysica
+cd pyphysica
+pip install -e ".[dev]"
+```
+
+## What it does
+
+**Decorator-based forces.** Annotate a class with `@continuous(obj)` to register
+each `Vector2` attribute as a per-step force, or `@impulse(obj)` for a one-shot
+impulse (`Δv = J/m`).
+
+**Time-varying forces.** `TimeVector` lets a force change over time, either
+symbolically in `T` or as a Python callable:
+
+```python
+from physica import TimeVector, T
+
+@continuous(obj)
+class Engine:
+    drive = TimeVector.of(lambda t: Vector2(4 * sp.sin(t), 0))   # callable
+    thrust = TimeVector(0, 120.0 - 3 * T)                        # symbolic in T
+```
+
+**Symbolic equations of motion.** Since forces may be expressions in `T`,
+`Object2` can return them as SymPy:
+
+```python
+ax, ay = obj.equation_of_motion()      # expressions in T
+ax, ay = obj.acceleration_func()       # T-bound Funcs
+vy     = obj.velocity_func()           # integrate once from rest
+y      = obj.position_func()           # integrate twice from rest
+sol    = obj.closed_form()             # dsolve, zero initial conditions
+```
+
+Multi-body systems:
+
+```python
+from physica import combine, describe_system
+
+print(describe_system([rocket, booster]))
+system = combine([rocket, booster])    # total mass, summed net force, per-body accel
+```
+
+**Symbolic math (`Func`/`Lim`).** A thin, ergonomic wrapper over SymPy:
+
+```python
+from physica import Func, Lim, x, T
+import sympy as sp
+
+f = Func(x**2 - 1)
+f(3)            # 8
+f[1]            # derivative  -> 2*x
+f[-1]           # antiderivative
+f[[0, 1]]       # definite integral
+(f @ Func(x + 1))     # composition
+Lim(sp.sin(x)/x, x, 0)   # 1
+
+g = Func(3 * T + 1, var=T)   # variable-aware: defaults to x
+```
+
+**Vectors and more.** `Vector2`, `Vector3`, `Quaternion`, and `Matrix` round out
+the math layer.
+
+## Example
+
+See [`examples/example_physics.py`](examples/example_physics.py) for seven
+worked examples — projectile with wind and an impulsive kick, a time-varying
+drive, multi-object systems, `simulate()` history, `Func` bootstrap over derived
+equations, and both the exact and small-angle pendulum.
+
+```sh
+python examples/example_physics.py
+```
+
+## Tests
+
+```sh
+pip install -e ".[dev]"
+pytest
+```
+
+## Physics notes
+
+- Integration is semi-implicit Euler, which introduces `O(dt)` energy drift.
+  Halving the timestep halves the drift.
+- `small-angle` checks against the analytic SHM solution agree to `< 1e-3`.
+- Equations of motion are derived from Newton's second law: `a = F_net / m`.
+
+## License
+
+MIT

pyphysica-0.1.0/examples/example_physics.py

@@ -0,0 +1,218 @@
+"""Example uses of the physica DSL.
+
+Run with:  python3 example_physics.py
+"""
+
+import sympy as sp
+from physica import Object2, Vector2, TimeVector, Time, T, x, Func, Lim, continuous, impulse, update, simulate, combine, describe_system
+
+
+# ---------------------------------------------------------------------------
+# 1. Projectile with gravity, a steady wind, and an impulsive kick
+# ---------------------------------------------------------------------------
+print("=" * 60)
+print("1. Projectile: gravity + wind + kick")
+print("=" * 60)
+
+ball = Object2("ball", mass=0.45, position=Vector2(0, 10), velocity=Vector2(5, 0))
+
+@continuous(ball)
+class Gravity:
+    gravity = Vector2(0, -9.81)
+
+@continuous(ball)
+class Wind:
+    wind = Vector2(2, 0)
+
+@impulse(ball)
+class Kick:
+    force = Vector2(50, 20)
+
+@update(ball)
+def physics(obj, dt):
+    obj.integrate(dt)
+    obj.clear_impulses()
+
+for _ in range(100):
+    physics(ball, 0.016)
+
+print(f"final position: {ball.position}")
+print(f"speed: {ball.speed()}, KE: {ball.kinetic_energy()}")
+print()
+
+
+# ---------------------------------------------------------------------------
+# 2. Time-varying force (sinusoidal drive) + closed form via sympy
+# ---------------------------------------------------------------------------
+print("=" * 60)
+print("2. Time-varying drive + symbolic combination")
+print("=" * 60)
+
+car = Object2("car", mass=2.0)
+
+@continuous(car)
+class Road:
+    push = Vector2(1.5, 0)
+
+@continuous(car)
+class Engine:
+    drive = TimeVector.of(lambda t: Vector2(4 * sp.sin(t), 0))
+
+print(car.describe())
+print("\nclosed form (dsolve):")
+for solution in car.closed_form():
+    print("  ", solution)
+print()
+
+
+# ---------------------------------------------------------------------------
+# 3. Multiple objects combined into one system
+# ---------------------------------------------------------------------------
+print("=" * 60)
+print("3. Multi-object system")
+print("=" * 60)
+
+rocket = Object2("rocket", mass=50.0)
+booster = Object2("booster", mass=10.0)
+
+@continuous(rocket)
+class Thrust:
+    force = TimeVector(0, 120.0 - 3 * T)   # thrust falls off with time
+
+@continuous(booster)
+class Boost:
+    force = Vector2(0, 30)
+
+print(describe_system([rocket, booster]))
+print()
+
+
+# ---------------------------------------------------------------------------
+# 4. Using a shared clock + simulate(), then replay the history
+# ---------------------------------------------------------------------------
+print("=" * 60)
+print("4. simulate() with a shared clock and history")
+print("=" * 60)
+
+clock = Time()
+probe = Object2("probe", mass=1.0, position=Vector2(0, 5))
+
+@continuous(probe)
+class Spring:
+    restoring = TimeVector.of(lambda t: Vector2(0, -2 * probe.position.y))
+
+history = simulate(probe, dt=0.1, length=10, time=clock)
+states = list(history.values())
+print(f"clock.t = {clock.t}")
+print(f"steps recorded = {len(history)}")
+print("first state:", states[0][0]["position"])
+print("last  state:", states[-1][0]["position"])
+print()
+
+
+# ---------------------------------------------------------------------------
+# 5. Bootstrap syntax (Func/Lim) applied to the derived equations of motion
+# ---------------------------------------------------------------------------
+print("=" * 60)
+print("5. Func bootstrap over the physics formulae")
+print("=" * 60)
+
+block = Object2("block", mass=2.0)
+
+@continuous(block)
+class Gravity:
+    gravity = Vector2(0, -9.81)
+
+@continuous(block)
+class Ramp:
+    push = TimeVector.of(lambda t: Vector2(2 * t, 0))
+
+ax, ay = block.acceleration_func()
+print(f"ax(T) = {ax}   ay(T) = {ay}")
+
+# Pretty syntax on the T-bound Funcs
+print(f"vx(T)  = ax[-1]   = {ax[-1]}")
+print(f"x(T)   = ax[-2]   = {ax[-2]}")
+print(f"jerk   = ax[1]    = {ax[1]}")
+print(f"ax solves zero at T = {ax.solve()}")
+print(f"average ax over [0, 3] = {ax[[0, 3]] / 3}")
+
+# The classic Func(x) behaviour is untouched
+f = Func(x**2 - 1)
+print(f"Func(x**2-1)(3) = {f(3)},  f[1] = {f[1]},  f[[0,1]] = {f[[0,1]]}")
+print(f"Lim(sin(x)/x, x, 0) = {Lim(sp.sin(x)/x, x, 0)}")
+print()
+
+
+# ---------------------------------------------------------------------------
+# 6. Pendulum — using the angular DOF (angle / angular_velocity / torque)
+# ---------------------------------------------------------------------------
+print("=" * 60)
+print("6. Pendulum")
+print("=" * 60)
+
+import math
+
+L, g, m = 1.0, 9.81, 0.5          # rod length, gravity, bob mass
+
+bob = Object2("bob", mass=m)
+bob.moment = m * L ** 2           # I = mL^2 for a point mass on a massless rod
+bob.angle = math.pi / 2           # start horizontal
+bob.angular_velocity = 0.0
+
+@update(bob)
+def pendulum(obj, dt):
+    obj.torque = -m * g * L * math.sin(obj.angle)   # restoring torque
+    obj.integrate(dt)
+    obj.position = Vector2(L * math.sin(obj.angle), -L * math.cos(obj.angle))
+
+def energy(o):
+    return 0.5 * o.moment * o.angular_velocity ** 2 - m * g * L * math.cos(o.angle)
+
+E0 = float(energy(bob))
+print(f"E(0) = {E0:.6g}")
+for _ in range(200):
+    pendulum(bob, 0.01)
+
+print(f"angle = {float(bob.angle):.6f} rad")
+print(f"omega = {float(bob.angular_velocity):.6f} rad/s")
+# Semi-implicit Euler drifts in energy, first-order in dt: halve dt -> halve drift.
+print(f"E(t)  = {float(energy(bob)):.6g}  (E0 = {E0:.6g}; drift is O(dt))")
+print(f"bob position (x, y) = {bob.position}")
+print()
+
+
+# ---------------------------------------------------------------------------
+# 7. Pendulum, small-angle approximation  sin(theta) ~ theta
+# ---------------------------------------------------------------------------
+print("=" * 60)
+print("7. Pendulum (small-angle: sin(theta) ~ theta)")
+print("=" * 60)
+
+theta0 = 0.1
+small = Object2("small", mass=m)
+small.moment = m * L ** 2
+small.angle = theta0
+small.angular_velocity = 0.0
+
+@update(small)
+def small_pendulum(obj, dt):
+    obj.torque = -m * g * L * obj.angle            # linear restoring torque
+    obj.integrate(dt)
+    obj.position = Vector2(L * math.sin(obj.angle), -L * math.cos(obj.angle))
+
+omega0 = math.sqrt(g / L)
+dt = 0.0005
+max_err = 0.0
+for i in range(1, 4001):
+    small_pendulum(small, dt)
+    t = i * dt
+    analytic = theta0 * math.cos(omega0 * t)       # exact SHM solution
+    max_err = max(max_err, abs(float(small.angle) - analytic))
+
+print(f"omega = sqrt(g/L) = {omega0:.6f} rad/s")
+print(f"period = 2*pi/omega = {2*math.pi/omega0:.6f} s")
+print(f"amplitude-independent (SHM), unlike the exact sin(theta) pendulum")
+print(f"max |numeric - {theta0}*cos(omega*t)| over 2 s = {max_err:.2e}")
+
+

pyphysica-0.1.0/pyproject.toml

@@ -0,0 +1,48 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pyphysica"
+version = "0.1.0"
+description = "A symbolic + numeric physics DSL: decorator-based forces, time-varying vectors, and sympy-derived equations of motion."
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+keywords = ["physics", "simulation", "sympy", "symbolic", "cas", "dsl", "mechanics"]
+authors = [{ name = "Rohan Hariharan" }]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Science/Research",
+    "Intended Audience :: Education",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Scientific/Engineering :: Physics",
+    "Topic :: Scientific/Engineering :: Mathematics",
+]
+dependencies = [
+    "numpy",
+    "sympy",
+]
+
+[project.urls]
+Homepage = "https://github.com/rohanhariharan/pyphysica"
+Repository = "https://github.com/rohanhariharan/pyphysica"
+Issues = "https://github.com/rohanhariharan/pyphysica/issues"
+
+[project.optional-dependencies]
+dev = ["pytest>=7", "build"]
+
+[tool.setuptools]
+package-dir = { "" = "src" }
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src"]

pyphysica-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+