API Reference

transient_analysis.routhTool.cli

transient_analysis.routhTool.cli.build_parser()[source]

Build the command-line parser.

Return type:

ArgumentParser

transient_analysis.routhTool.cli.cli(argv=None)[source]

Run the Routh command-line interface.

Parameters:

argv (list[str] | None)

Return type:

int

transient_analysis.routhTool.app

class transient_analysis.routhTool.app.RouthApp(paths, builder)[source]

Bases: object

High-level façade for the routhTool within modernControl.

Parameters:
builder: RouthArrayBuilder
classmethod discover(package_dir)[source]
Parameters:

package_dir (Path)

Return type:

RouthApp

paths: RouthPaths
run(coeffs_raw, *, symbols=None, solve_for=None, eps=1e-09, compute_hurwitz=False, verify_numeric=False, export_basename=None)[source]
Parameters:

  • coeffs_raw (str)

  • symbols (list[str] | None)

  • solve_for (str | None)

  • eps (float)

  • compute_hurwitz (bool)

  • verify_numeric (bool)

  • export_basename (str | None)

Return type:

Dict[str, Any]

transient_analysis.routhTool.apis

class transient_analysis.routhTool.apis.RouthRequest(coeffs, symbols=None, solve_for=None, eps=1e-09, compute_hurwitz=False, verify_numeric=False)[source]

Bases: object

Programmatic request payload.

Parameters:

  • coeffs (str)

  • symbols (List[str] | None)

  • solve_for (str | None)

  • eps (float)

  • compute_hurwitz (bool)

  • verify_numeric (bool)

coeffs: str
compute_hurwitz: bool
eps: float
solve_for: str | None
symbols: List[str] | None
verify_numeric: bool
class transient_analysis.routhTool.apis.RouthResponse(array, first_column, degrees, rhp_by_routh, rhp_by_roots, hurwitz_minors, stability_condition)[source]

Bases: object

Programmatic response payload (JSON-safe-ish).

Parameters:

  • array (List[List[str]])

  • first_column (List[str])

  • degrees (List[int])

  • rhp_by_routh (int | None)

  • rhp_by_roots (int | None)

  • hurwitz_minors (List[str] | None)

  • stability_condition (str | None)

array: List[List[str]]
degrees: List[int]
first_column: List[str]
hurwitz_minors: List[str] | None
rhp_by_roots: int | None
rhp_by_routh: int | None
stability_condition: str | None
transient_analysis.routhTool.apis.array_api(req)[source]
Parameters:

req (RouthRequest)

Return type:

RouthResponse

transient_analysis.routhTool.apis.solve_api(coeffs, symbol, *, eps=1e-09)[source]
Parameters:

  • coeffs (str)

  • symbol (str)

  • eps (float)

Return type:

RouthResponse

transient_analysis.routhTool.core

class transient_analysis.routhTool.core.RouthArrayBuilder(config=None)[source]

Bases: object

Build Routh arrays numerically or symbolically. - ε-trick for zero leading element in a row. - Auxiliary polynomial when an entire row becomes zero. - Optional: Hurwitz minors (SymPy), inequality solving for 1 symbol, numeric verification.

The class is stateless and thus easy to test; config is injected via RouthConfig.

Parameters:

config (Optional[RouthConfig])

build_array(coeffs)[source]
Parameters:

coeffs (Sequence[float | int | Basic])

Return type:

Tuple[List[List[float | int | Basic]], List[float | int | Basic], List[int]]

hurwitz_minors(coeffs)[source]
Parameters:

coeffs (Sequence[float | int | Basic])

Return type:

List[Basic]

run(coeffs, *, symbol_to_solve=None, compute_hurwitz=False, verify_numeric=False)[source]
Parameters:

  • coeffs (Sequence[float | int | Basic])

  • symbol_to_solve (str | None)

  • compute_hurwitz (bool)

  • verify_numeric (bool)

Return type:

RouthResult

sign_changes_first_column(first_col)[source]
Parameters:

first_col (Sequence[float | int | Basic])

Return type:

int | None

stability_region_for(first_col, symbol_name)[source]
Parameters:

  • first_col (Sequence[float | int | Basic])

  • symbol_name (str)

verify_with_roots(coeffs)[source]
Parameters:

coeffs (Sequence[float | int | Basic])

Return type:

int | None

class transient_analysis.routhTool.core.RouthConfig(eps=1e-09)[source]

Bases: object

Config knobs for Routh builder.

Parameters:

eps (float)

eps: float
class transient_analysis.routhTool.core.RouthResult(array, first_column, degrees, rhp_by_routh=None, rhp_by_roots=None, hurwitz_minors=None, stability_condition=None)[source]

Bases: object

Container for results of building a Routh array.

Parameters:

  • array (List[List[float | int | Basic]])

  • first_column (List[float | int | Basic])

  • degrees (List[int])

  • rhp_by_routh (int | None)

  • rhp_by_roots (int | None)

  • hurwitz_minors (List[Basic] | None)

  • stability_condition (object | None)

array: List[List[float | int | Basic]]
degrees: List[int]
first_column: List[float | int | Basic]
hurwitz_minors: List[Basic] | None
rhp_by_roots: int | None
rhp_by_routh: int | None
stability_condition: object | None

transient_analysis.routhTool.design

class transient_analysis.routhTool.design.RouthPreset(name, coeffs, symbols=None, solve_for=None)[source]

Bases: object

Small catalog for quick demos / docs / tests.

Parameters:

  • name (str)

  • coeffs (str)

  • symbols (List[str] | None)

  • solve_for (str | None)

coeffs: str
name: str
solve_for: str | None
symbols: List[str] | None

transient_analysis.routhTool.io

class transient_analysis.routhTool.io.RouthPaths(root: 'Path', in_dir: 'Path', out_dir: 'Path')[source]

Bases: object

Parameters:

  • root (Path)

  • in_dir (Path)

  • out_dir (Path)

classmethod from_package_root(package_root)[source]
Parameters:

package_root (Path)

Return type:

RouthPaths

in_dir: Path
out_dir: Path
root: Path
transient_analysis.routhTool.io.dump_json(out_path, obj, *, encoding='utf-8')[source]
Parameters:

  • out_path (Path)

  • obj (Dict[str, Any])

Return type:

Path

transient_analysis.routhTool.io.ensure_dirs(paths)[source]
Parameters:

paths (RouthPaths)

transient_analysis.routhTool.io.write_text(out_path, text, *, encoding='utf-8')[source]
Parameters:

  • out_path (Path)

  • text (str)

Return type:

Path

transient_analysis.routhTool.utils

Utility helpers for transient_analysis.routhTool.

This module intentionally keeps parsing and formatting logic small and side-effect free so it can be reused by the CLI, app façade, and API layer.

transient_analysis.routhTool.utils.coerce_tokens(tokens, symbol_names)[source]

Convert coefficient tokens into numeric or symbolic objects.

The coercion policy is deliberately conservative. Declared symbol names are converted to SymPy symbols. All other tokens are parsed as floats first. If float parsing fails and SymPy is installed, the token is parsed with sympy.nsimplify. This keeps numeric Routh workflows numeric while still supporting symbolic gain parameters such as K.

Parameters:

  • tokens (Sequence[str]) – Tokenized coefficient values in descending polynomial order.

  • symbol_names (Sequence[str] | None) – Names that should be treated as symbolic parameters.

Returns:

A list containing floats and, when SymPy is available, symbolic values.

Raises:

ValueError – If a symbolic token is requested without SymPy, or if a non-numeric token cannot be parsed without SymPy.

Return type:

list[float | int | Basic]

transient_analysis.routhTool.utils.fmt_cell(x)[source]

Format a Routh-table cell for console and JSON-safe output.

Parameters:

x (Any)

Return type:

str

transient_analysis.routhTool.utils.parse_coeffs(raw)[source]

Parse a coefficient string into individual token strings.

Accepted separators are commas, semicolons, and whitespace. Square brackets are ignored so users can pass values such as [1, 5, 6, K] from the CLI.

Parameters:

raw (str) – Coefficients in descending polynomial order.

Returns:

A list of non-empty coefficient tokens.

Return type:

list[str]