https://github.com/galihru/laplapy
Symbolic Differentiation & Laplace Transform Utility A scientific Python library for step-by-step symbolic computation of time-domain derivatives and their Laplace transforms.
https://github.com/galihru/laplapy
computation-physics laplacian library python
Last synced: 11 months ago
JSON representation
Symbolic Differentiation & Laplace Transform Utility A scientific Python library for step-by-step symbolic computation of time-domain derivatives and their Laplace transforms.
- Host: GitHub
- URL: https://github.com/galihru/laplapy
- Owner: galihru
- License: mit
- Created: 2025-06-16T06:35:09.000Z (about 1 year ago)
- Default Branch: main
- Last Pushed: 2025-06-29T12:52:34.000Z (about 1 year ago)
- Last Synced: 2025-07-22T02:12:28.029Z (12 months ago)
- Topics: computation-physics, laplacian, library, python
- Language: Python
- Homepage:
- Size: 200 KB
- Stars: 1
- Watchers: 0
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
# LaplaPy: Advanced Symbolic Laplace Transform Analysis
[](https://pypi.org/project/LaplaPy/)
[](https://pepy.tech/project/LaplaPy)
[](https://github.com/4211421036/LaplaPy/actions)
[](LICENSE)
---
## Overview
**LaplaPy** is a professional-grade Python library for:
* **Symbolic Laplace transforms** with rigorous *Region of Convergence* (ROC) analysis
* **Linear ODE solving** via Laplace methods, including initial conditions
* **Control system analysis**: pole-zero maps, stability checks, frequency/time responses
* **Educational, step-by-step output modes** for teaching and self-study
Designed for engineers, scientists, and researchers in control theory, signal processing, electrical/mechanical systems, and applied mathematics.
---
## Features
1. **Forward & Inverse Laplace** with automatic ROC determination
2. **ODE Solver**: direct transform–solve–invert workflow for linear constant-coefficient equations
3. **Pole-Zero Analysis**: identify all poles and zeros symbolically
4. **Stability Assessment**: evaluate pole locations in the complex plane
5. **Frequency Response & Bode**: generate magnitude/phase plots data for `ω ∈ [ω_min, ω_max]`
6. **Time-Domain Response**: compute response to arbitrary inputs (e.g., steps, impulses, sinusoids)
7. **Causal/Non-Causal Modes**: model physical vs. mathematical systems
8. **Step-by-Step Tracing**: verbose mode to print every algebraic step (educational)
---
## Installation
**From PyPI**:
```bash
pip install LaplaPy
```
**From source (dev)**:
```bash
git clone https://github.com/4211421036/LaplaPy.git
cd LaplaPy
pip install -e .[dev]
```
Dependencies: `sympy>=1.10`, `numpy`.
---
## Quickstart Examples
### 1. Basic Laplace Transform
```python
from LaplaPy import LaplaceOperator, t, s
# f(t) = e^{-3t} + sin(2t)
op = LaplaceOperator("exp(-3*t) + sin(2*t)", show_steps=False)
F_s = op.forward_laplace()
print("F(s) =", F_s) # 1/(s+3) + 2/(s^2+4)
print("ROC:", op.roc) # Re(s) > -3
```
### 2. Inverse Transform
```python
# Recover f(t)
f_recov = op.inverse_laplace()
print("f(t) =", f_recov) # exp(-3*t) + sin(2*t)
```
### 3. Solve ODE
```python
from sympy import Eq, Function, Derivative, exp
f = Function('f')(t)
ode = Eq(Derivative(f, t, 2) + 3*Derivative(f, t) + 2*f,
exp(-t))
# ICs: f(0)=0, f'(0)=1
sol = LaplaceOperator(0).solve_ode(node,
{f.subs(t,0):0, Derivative(f,t).subs(t,0):1})
print(sol) # (e^{-t} - e^{-2t})
```
### 4. System Analysis & Bode Data
```python
# H(s) = (s+1)/(s^2+0.2*s+1)
op = LaplaceOperator("(s+1)/(s**2+0.2*s+1)")
op.forward_laplace()
analysis = op.system_analysis()
# poles, zeros, stability
defp print(analysis)
# Bode data
ω, mag_db, phase = op.bode_plot(w_min=0.1, w_max=100, points=200)
```
### 5. Time-Domain Response
```python
# Response to sin(4t)
r = op.time_domain_response("sin(4*t)")
print(r)
```
---
## CLI Usage
The `LaplaPy` console script provides a quick interface:
```bash
# Laplace transform + 2nd derivative:
LaplaPy "exp(-2*t)*sin(3*t)" --laplace
# Inverse Laplace:
LaplaPy "1/(s**2+4)" --inverse
# Solve ODE with ICs:
LaplaPy "f''(t)+4*f(t)=exp(-t)" --ode \
--ic "f(0)=0" "f'(0)=1"
```
**Flags**:
* `--laplace` (`-L`) : forward transform
* `--inverse` (`-I`): inverse transform
* `--ode` (`-O`) : solve ODE
* `--ic`: initial conditions
* `--quiet`: suppress verbose steps
* `--causal/--noncausal`: choose system causality
---
## 📚 Mathematical Foundations
### Laplace Transform Definition
$$
\mathcal{L}\{f(t)\}(s)
= \int_{0^-}^{\infty} e^{-st}f(t)\,dt
$$
### Derivative Property
$$
\mathcal{L}\{f^{(n)}(t)\}(s)
= s^nF(s)-\sum_{k=0}^{n-1}s^{n-1-k}f^{(k)}(0^+)
$$
### Region of Convergence (ROC)
* For causal signals: \$\mathrm{Re}(s) > \max(\mathrm{Re}(\text{poles}))\$
* ROC ensures transform integrals converge and stability criteria
### Pole-Zero & Stability
* **Poles**: roots of denominator \$D(s)=0\$
* **Zeros**: roots of numerator \$N(s)=0\$
* **Stability**: all poles in left-half complex plane
### Frequency Response
$$
H(j\omega)=H(s)\big|_{s=j\omega}
=|H(j\omega)|e^{j\angle H(j\omega)}
$$
---
## Development & Testing
```bash
# Install dev extras
pip install -e .[dev]
# Run test suite
pytest -q
# Lint with ruff
ruff .
# Type-check (mypy)
mypy LaplaPy
```
---
## License
Distributed under the **MIT License**. See [LICENSE](LICENSE) for details.
---
## Citation
```bibtex
@software{LaplaPy,
author = {GALIH RIDHO UTOMO},
title = {LaplaPy: Advanced Symbolic Laplace Transform Analysis},
year = {2025},
url = {https://github.com/4211421036/LaplaPy},
version = {0.2.2}
}
```