API Reference

state_space.stateSolverTool.cli

Command-line interface for state_space.stateSolverTool.

The CLI supports two usage styles:

  1. Modern subcommand form:

    python -m state_space.stateSolverTool.cli run --example ogata_5_2

  2. Historical no-subcommand form:

    python -m state_space.stateSolverTool.cli --example ogata_5_2

It also includes a sphinx-skel helper for generating a conservative, GitHub Pages friendly Sphinx documentation skeleton.

state_space.stateSolverTool.cli.build_parser()[source]

Build the command-line parser.

Return type:

ArgumentParser

state_space.stateSolverTool.cli.main(argv=None)[source]

Run the stateSolverTool command-line interface.

Parameters:

argv (list[str] | None)

Return type:

int

state_space.stateSolverTool.apis

class state_space.stateSolverTool.apis.LTIResult(matrices, zI_minus_G=None, inv_zI_minus_G=None, det_zI_minus_G=None, adj_zI_minus_G=None, leverrier_a=None, leverrier_H=None, Psi=None, xk=None, yk=None, check_status=None, latex_lines=None)[source]

Bases: object

Outputs from an LTI run.

Parameters:

  • matrices (MatrixBundle)

  • zI_minus_G (sympy.Matrix | None)

  • inv_zI_minus_G (sympy.Matrix | None)

  • det_zI_minus_G (sympy.Expr | None)

  • adj_zI_minus_G (sympy.Matrix | None)

  • leverrier_a (List[sympy.Expr] | None)

  • leverrier_H (List[sympy.Matrix] | None)

  • Psi (sympy.Matrix | None)

  • xk (sympy.Matrix | None)

  • yk (sympy.Matrix | None)

  • check_status (str | None)

  • latex_lines (List[str] | None)

Psi: sympy.Matrix | None = None
adj_zI_minus_G: sympy.Matrix | None = None
check_status: str | None = None
det_zI_minus_G: sympy.Expr | None = None
inv_zI_minus_G: sympy.Matrix | None = None
latex_lines: List[str] | None = None
leverrier_H: List[sympy.Matrix] | None = None
leverrier_a: List[sympy.Expr] | None = None
matrices: MatrixBundle
xk: sympy.Matrix | None = None
yk: sympy.Matrix | None = None
zI_minus_G: sympy.Matrix | None = None
class state_space.stateSolverTool.apis.LTVResult(Phi=None, xs=None, ys=None, check_status=None, latex_lines=None)[source]

Bases: object

Outputs from an LTV run.

Parameters:

  • Phi (sympy.Matrix | None)

  • xs (List[sympy.Matrix] | None)

  • ys (List[sympy.Matrix] | None)

  • check_status (str | None)

  • latex_lines (List[str] | None)

Phi: sympy.Matrix | None = None
check_status: str | None = None
latex_lines: List[str] | None = None
xs: List[sympy.Matrix] | None = None
ys: List[sympy.Matrix] | None = None
class state_space.stateSolverTool.apis.MatrixBundle(G=None, H=None, C=None, D=None, x0=None, u_expr=None)[source]

Bases: object

Structured matrices and expressions for introspection/testing.

Parameters:

  • G (sympy.Matrix | None)

  • H (sympy.Matrix | None)

  • C (sympy.Matrix | None)

  • D (sympy.Matrix | None)

  • x0 (sympy.Matrix | None)

  • u_expr (sympy.Expr | None)

C: sympy.Matrix | None = None
D: sympy.Matrix | None = None
G: sympy.Matrix | None = None
H: sympy.Matrix | None = None
u_expr: sympy.Expr | None = None
x0: sympy.Matrix | None = None
class state_space.stateSolverTool.apis.RunRequest(mode='lti', example=None, G=None, H=None, C=None, D=None, x0=None, u=None, Gk=None, Hk=None, Ck=None, Dk=None, latex=False, latex_out=None, zt=False, realblocks=False, steps=6, check='brief', power_style='rational')[source]

Bases: object

User-facing API for running the State Solver tool.

Parameters:

  • mode (str)

  • example (str | None)

  • G (str | None)

  • H (str | None)

  • C (str | None)

  • D (str | None)

  • x0 (str | None)

  • u (str | None)

  • Gk (str | None)

  • Hk (str | None)

  • Ck (str | None)

  • Dk (str | None)

  • latex (bool)

  • latex_out (str | None)

  • zt (bool)

  • realblocks (bool)

  • steps (int)

  • check (str)

  • power_style (str)

C: str | None = None
Ck: str | None = None
D: str | None = None
Dk: str | None = None
G: str | None = None
Gk: str | None = None
H: str | None = None
Hk: str | None = None
check: str = 'brief'
example: str | None = None
latex: bool = False
latex_out: str | None = None
mode: str = 'lti'
power_style: str = 'rational'
realblocks: bool = False
steps: int = 6
u: str | None = None
x0: str | None = None
zt: bool = False
class state_space.stateSolverTool.apis.RunResult(mode: 'str', lti: 'Optional[LTIResult]' = None, ltv: 'Optional[LTVResult]' = None)[source]

Bases: object

Parameters:
lti: LTIResult | None = None
ltv: LTVResult | None = None
mode: str

state_space.stateSolverTool.app

class state_space.stateSolverTool.app.StateSolverApp(pkg_dir)[source]

Bases: object

Application orchestrator for the State Solver tool.

Parameters:

pkg_dir (str)

run(req)[source]
Parameters:

req (RunRequest)

Return type:

RunResult

state_space.stateSolverTool.core

state_space.stateSolverTool.core.adj_via_leverrier(H_list, z)[source]
Parameters:

  • H_list (List[sympy.Matrix])

  • z (sympy.Symbol)

Return type:

sympy.Matrix

state_space.stateSolverTool.core.apply_power_style(expr, style='rational')[source]
Parameters:

style (str)

state_space.stateSolverTool.core.apply_power_style_to_matrix(M, style='rational')[source]
Parameters:

  • M (sympy.Matrix)

  • style (str)

Return type:

sympy.Matrix

state_space.stateSolverTool.core.brief_check_lti(G, H, C, D, x0, u_expr, Psi, xk_expr, yk_expr, steps=6, tol=1e-09)[source]
Parameters:

  • steps (int)

  • tol (float)

Return type:

str

state_space.stateSolverTool.core.brief_check_ltv(Gk, Hk, Ck, Dk, x0, u_expr, steps=5, tol=1e-09)[source]
Parameters:

  • steps (int)

  • tol (float)

state_space.stateSolverTool.core.example_system(name)[source]
Parameters:

name (str)

state_space.stateSolverTool.core.inverse_zI_minus_G(G, z)[source]
Parameters:

  • G (sympy.Matrix)

  • z (sympy.Symbol)

state_space.stateSolverTool.core.jordan_block_power(lam, m, k)[source]
Parameters:

  • lam (sympy.Expr)

  • m (int)

  • k (sympy.Symbol)

Return type:

sympy.Matrix

state_space.stateSolverTool.core.leverrier_faddeev(A)[source]
Parameters:

A (sympy.Matrix)

Return type:

Tuple[List[sympy.Expr], List[sympy.Matrix]]

state_space.stateSolverTool.core.lti_solution(G, H, C, D, x0, u_expr, k, power_style='rational')[source]
Parameters:

  • G (sympy.Matrix)

  • H (sympy.Matrix)

  • C (sympy.Matrix)

  • D (sympy.Matrix)

  • x0 (sympy.Matrix)

  • u_expr (sympy.Expr)

  • k (sympy.Symbol)

  • power_style (str)

state_space.stateSolverTool.core.matrix_power_symbolic(G, k)[source]
Parameters:

  • G (sympy.Matrix)

  • k (sympy.Symbol)

Return type:

Tuple[sympy.Matrix, sympy.Matrix | None]

state_space.stateSolverTool.core.z_transform_block(G, H, C, D, x0, u_expr, z)[source]
Parameters:

  • G (sympy.Matrix)

  • H (sympy.Matrix)

  • C (sympy.Matrix)

  • D (sympy.Matrix)

  • x0 (sympy.Matrix)

  • u_expr (sympy.Expr)

  • z (sympy.Symbol)

Return type:

List[str]

state_space.stateSolverTool.io

state_space.stateSolverTool.io.fmt_matrix_for_console(M)[source]
Parameters:

M (sympy.Matrix)

Return type:

str

state_space.stateSolverTool.io.latex_mat(M)[source]
Parameters:

M (sympy.Matrix)

Return type:

str

state_space.stateSolverTool.io.parse_matrix(s, allow_k=False)[source]
Parameters:

  • s (str)

  • allow_k (bool)

Return type:

sympy.Matrix

state_space.stateSolverTool.io.parse_scalar_expr(s, allow_k=False)[source]
Parameters:

  • s (str)

  • allow_k (bool)

Return type:

sympy.Expr

state_space.stateSolverTool.io.parse_vector(s, allow_k=False)[source]
Parameters:

  • s (str)

  • allow_k (bool)

Return type:

sympy.Matrix

state_space.stateSolverTool.utils

state_space.stateSolverTool.utils.out_path(pkg_dir, *parts)[source]

Resolve an output path under this package’s out/ directory.

Parameters:

  • pkg_dir (str)

  • parts (str)

Return type:

str

state_space.stateSolverTool.utils.timeit(func)[source]
Parameters:

func (Callable[[...], Any])

Return type:

Callable[[…], Any]

state_space.stateSolverTool.design

state_space.stateSolverTool.design.lti_latex_block(G, H, C, D, x0, u_expr, inv, z, Psi, xk, yk, real_modal=None, include_zt=False)[source]
Parameters:

include_zt (bool)

Return type:

List[str]