API Reference¶
z_transform.zTransformTool.cli¶
Command-line interface for z_transform.zTransformTool.
The CLI supports two usage styles:
Modern subcommand form:
python -m z_transform.zTransformTool.cli run --z --expr "a**k"
Historical no-subcommand form:
python -m z_transform.zTransformTool.cli --z --expr "a**k"
It also includes a sphinx-skel helper for generating a conservative,
GitHub Pages friendly Sphinx documentation skeleton.
z_transform.zTransformTool.apis¶
apis.py — Public API dataclasses for zTransformTool.
- class z_transform.zTransformTool.apis.RunRequest(mode: 'str', expr: 'Optional[str]' = None, xt: 'Optional[str]' = None, X: 'Optional[str]' = None, subs: 'Optional[str]' = None, N: 'Optional[int]' = None, latex: 'bool' = False, export_csv: 'Optional[str]' = None, export_json: 'Optional[str]' = None, num: 'Optional[str]' = None, den: 'Optional[str]' = None, dt: 'float' = 1.0, impulse: 'bool' = False, step: 'bool' = False, u: 'Optional[str]' = None, rec: 'Optional[str]' = None, a: 'Optional[str]' = None, rhs: 'Optional[str]' = None, ics: 'Optional[str]' = None)[source]¶
Bases:
object- Parameters:
mode (str)
expr (str | None)
xt (str | None)
X (str | None)
subs (str | None)
N (int | None)
latex (bool)
export_csv (str | None)
export_json (str | None)
num (str | None)
den (str | None)
dt (float)
impulse (bool)
step (bool)
u (str | None)
rec (str | None)
a (str | None)
rhs (str | None)
ics (str | None)
- N: int | None = None¶
- X: str | None = None¶
- a: str | None = None¶
- den: str | None = None¶
- dt: float = 1.0¶
- export_csv: str | None = None¶
- export_json: str | None = None¶
- expr: str | None = None¶
- ics: str | None = None¶
- impulse: bool = False¶
- latex: bool = False¶
- mode: str¶
- num: str | None = None¶
- rec: str | None = None¶
- rhs: str | None = None¶
- step: bool = False¶
- subs: str | None = None¶
- u: str | None = None¶
- xt: str | None = None¶
z_transform.zTransformTool.app¶
app.py — Orchestrator for zTransformTool.
- class z_transform.zTransformTool.app.ZTApp(print_boxes=True)[source]¶
Bases:
object- Parameters:
print_boxes (bool)
- run(req)[source]¶
- Parameters:
req (RunRequest)
- Return type:
Dict[str, Any]
z_transform.zTransformTool.core¶
Pure computational routines for zTransformTool.
This module intentionally avoids command-line parsing and printing. It contains symbolic and numeric helpers for forward z transforms, unilateral inverse z transforms, finite series expansion, transfer-function utilities, and difference-equation solving.
The inverse-z workflow is written around the substitution u = 1/z. Rational
expressions are converted to B(u) / A(u) with A(0) nonzero when possible.
The finite unilateral sequence is computed from the recurrence, and the symbolic
closed form is matched back to those recurrence samples so repeated poles,
polynomial factors in k, and input delays remain consistent with the
unilateral convention.
- z_transform.zTransformTool.core.forward_z_closed_form(xk, z, k)[source]¶
- Ogata-style pairs:
1 -> z/(z-1) r^k -> z/(z-r) sin(Ωk) -> z*sinΩ / (z^2 - 2z cosΩ + 1) cos(Ωk) -> z(z - cosΩ) / (z^2 - 2z cosΩ + 1) r^k sin(Ωk) -> z r sinΩ / (z^2 - 2 r z cosΩ + r**2) r^k cos(Ωk) -> z (z - r cosΩ) / (z^2 - 2 r z cosΩ + r**2)
- z_transform.zTransformTool.core.forward_z_from_xt(xt, syms, subs=None)[source]¶
- Parameters:
subs (Dict)
- z_transform.zTransformTool.core.impulse_response_closed(A, k_sym)[source]¶
Impulse response of H(u)=1/A(u): Solve sum_{i=0}^n a_i h[k-i] = δ[k] with a_0 != 0. We compute h[0..n-1] from the recurrence (unilateral), then solve the homogeneous equation with those ICs to get a clean closed form.
- Parameters:
A (sympy.Poly)
k_sym (sympy.Symbol)
- Return type:
sympy.Expr
- z_transform.zTransformTool.core.inverse_z(X, syms, N=None, subs=None)[source]¶
- Parameters:
N (int | None)
subs (Dict)
- z_transform.zTransformTool.core.inverse_z_unilateral(XZ, z, k, N)[source]¶
Build Xu(u), get A(u), B(u), compute seq by convolution, and ALWAYS build a closed form via x[k] = sum_i b_i h[k-i] Heaviside(k-i, 1), then fit the closed form to the recurrence samples with a homogeneous correction (guarantees equality to the unilateral sequence).
- Parameters:
N (int | None)
- z_transform.zTransformTool.core.rational_AB_in_u(Xu, u)[source]¶
Return polynomials A(u), B(u) with X(u) = B(u)/A(u), ensuring: - no negative powers of u - A(0) != 0 (divide out leading u factors if necessary, adjusting B too)
- Return type:
Tuple[sympy.Poly, sympy.Poly]
- z_transform.zTransformTool.core.seq_by_convolution(A, B, N)[source]¶
Finite-length unilateral sequence from A(u) X(u) = B(u).
- Parameters:
A (sympy.Poly)
B (sympy.Poly)
N (int)
- Return type:
List[sympy.Expr]
- z_transform.zTransformTool.core.series_in_u(X, syms, N, subs=None)[source]¶
- Parameters:
N (int)
subs (Dict)
z_transform.zTransformTool.io¶
io.py — Parsing and I/O helpers for zTransformTool.
- z_transform.zTransformTool.io.export_sequence(rows, values, name, export_csv, export_json)[source]¶
- Parameters:
name (str)
export_csv (str | None)
export_json (str | None)
- Return type:
None
- z_transform.zTransformTool.io.parse_coeffs_numeric(s)[source]¶
- Parameters:
s (str)
- Return type:
List[float]
z_transform.zTransformTool.utils¶
utils.py — Shared utilities for zTransformTool.
- z_transform.zTransformTool.utils.ensure_out_dir(path=None)[source]¶
Ensure the out directory exists. If path is provided and is absolute, ensure its parent exists and return path. If path is a relative filename, rewrite to our package out/ directory.
- Parameters:
path (str | None)
- Return type:
str
- z_transform.zTransformTool.utils.force_out_path(path)[source]¶
Map a possibly-relative path to the package out/ folder; absolute paths are respected.
- Parameters:
path (str | None)
- Return type:
str | None
- z_transform.zTransformTool.utils.pbox(title, obj, latex=False)[source]¶
Format a pretty box string (returned). The App decides whether to print it.
- Parameters:
title (str)
latex (bool)
- Return type:
str
z_transform.zTransformTool.design¶
design.py — Presentation helpers for zTransformTool (formatting, strings).