Comparing Routh-hurwitz with Jury’s Stability Test for Discrete Systems

Introduction to Stability Analysis in Discrete Systems

Stability analysis forms the backbone of control system engineering, ensuring that a system responds predictably and remains bounded under normal operating conditions. For discrete-time systems—common in digital control, signal processing, and embedded applications—the stability criterion shifts from the continuous s-plane left-half plane to the unit circle in the z-plane. Engineers rely on robust analytical tools to determine whether all poles of a discrete transfer function reside inside the unit circle without explicitly solving high-order polynomials. Two prominent methods are the Routh-Hurwitz criterion, originally developed for continuous systems but adaptable to discrete frameworks, and Jury’s stability test, purpose-built for discrete-time analysis. Understanding when and how to apply each method is critical for designing reliable digital controllers and sampled-data systems.

This article provides a comprehensive comparison of Routh-Hurwitz and Jury’s stability test, exploring their mathematical foundations, procedural steps, practical adaptations, and relative strengths. By the end, engineers and students alike will have a clear roadmap for selecting the appropriate technique for their discrete system analysis needs.

Discrete System Stability: The Unit Circle Criterion

Before diving into the specific methods, it is essential to recall the fundamental stability condition for discrete-time systems. A linear time-invariant discrete system described by the transfer function H(z) = N(z) / D(z) is stable if and only if all the poles—the roots of the characteristic polynomial D(z) = 0—lie inside the unit circle in the z-plane, i.e., |z| < 1. This condition differs markedly from continuous systems, where stability requires all poles to have negative real parts (left-half plane).

While root-finding algorithms can directly compute pole locations, they become cumbersome for high-order polynomials. Hence, algebraic criteria like Routh-Hurwitz and Jury’s test offer efficient, non-iterative checks. The key challenge is that Jury’s test operates directly on the coefficients of D(z), whereas Routh-Hurwitz typically works on polynomials in the s-domain. A transformation is thus necessary to apply Routh-Hurwitz to discrete systems.

Routh-Hurwitz Criterion and Its Adaptation to Discrete Systems

Classical Routh-Hurwitz for Continuous Systems

The Routh-Hurwitz criterion provides necessary and sufficient conditions for stability of continuous linear systems. Given a characteristic polynomial

a₀sⁿ + a₁s^n–1 + … + a_n = 0

the method constructs a Routh array from the coefficients. The system is stable if all elements in the first column of the array are positive and nonzero. A sign change indicates roots in the right-half plane and thus instability. This approach avoids explicit root calculation and is straightforward for polynomials up to moderate orders.

Bilinear Transformation: Converting the z-Plane to the s-Plane

To apply Routh-Hurwitz to discrete systems, engineers use the bilinear transformation (also called Tustin’s transformation). This mapping relates the z variable to a new complex variable w (often denoted as s for convenience after transformation):

z = (1 + wT/2) / (1 – wT/2)

or, for normalized sampling period T = 2, the simpler form z = (1 + w) / (1 – w). Under this bilinear map, the interior of the unit circle in the z-plane maps to the left-half plane in the w-plane. Consequently, the transformed polynomial in w can be analyzed using the standard Routh-Hurwitz array.

Steps for Applying Routh-Hurwitz to Discrete Systems

Obtain the discrete characteristic polynomial D(z) from the system’s transfer function.
Substitute the bilinear transformation into D(z) to obtain a polynomial in w. This step may involve algebraic expansion and simplification, especially for higher-order systems.
Apply the Routh-Hurwitz criterion to the transformed polynomial in w. Construct the Routh array and examine the signs of the first-column entries.
Stability conclusion: If all first-column entries are positive, the discrete system is stable (all poles inside the unit circle). Any sign changes indicate the number of poles outside the unit circle.

While this approach works, it introduces additional algebraic complexity. The bilinear transformation can significantly increase the polynomial order if not handled carefully. Moreover, the transformation itself can become a source of numerical error, especially for high-order systems or when sampling periods are not normalized properly. Despite these drawbacks, the Routh-Hurwitz method remains a viable option for engineers already familiar with its continuous-system application and who prefer a single unified framework.

Limitations of the Routh-Hurwitz Adaptation

Algebraic burden: The bilinear transformation expands the polynomial, potentially introducing rounding errors and making manual calculations tedious.
Numerical sensitivity: For high-order polynomials, the coefficient magnitudes can vary widely, leading to ill-conditioned arrays.
Special cases: The method requires handling auxiliary polynomials for roots on the imaginary axis (in the w-plane) which correspond to poles on the unit circle – a marginal stability condition that is often undesired.
Inefficiency for purely discrete systems: Because the method is not native to the discrete domain, many control textbooks recommend Jury’s test as the more direct and less error-prone alternative.

Nevertheless, the Routh-Hurwitz criterion is sometimes taught in control courses as a bridge between continuous and discrete analysis, and it can be applied using symbolic computation tools to mitigate algebraic difficulties.

Jury’s Stability Test: Designed for the Discrete Domain

Origins and Principle

Jury’s stability test, introduced by Eliahu I. Jury in the 1960s, is the discrete counterpart of the Routh-Hurwitz criterion. It directly examines the coefficients of the characteristic polynomial D(z) without requiring domain transformations. Instead of checking the sign of first-column entries, Jury’s test constructs a table (the Jury table) from the polynomial coefficients and enforces a set of conditions that guarantee all roots have magnitude less than one.

Consider the monic characteristic polynomial of order n:

D(z) = a₀zⁿ + a₁z^n–1 + … + a_n–1z + a_n = 0, with a₀ > 0.

Jury’s test provides a systematic procedure to determine whether all roots lie inside the unit circle by forming a table with n + 1 rows. The rows are generated sequentially using determinant calculations involving the coefficients.

Procedure for Constructing the Jury Table

List the coefficients in the first row (row 0) in natural order: a₀, a₁, …, a_n.
Form the second row (row 1) by reversing the order of the coefficients in row 0: a_n, a_n–1, …, a₀.
For subsequent rows (k = 2, 3, …), compute the Jury determinants for each pair of rows. Typically, the element at position (k, i) is given by:

b_i = a₀ * a_{i + 1} – a_{n – i} * a_n

where the indices are adjusted based on the current row pair. The exact formula varies with implementation; common textbooks present a recursive algorithm that reduces the polynomial order by one after each pair of rows.
Continue until only one nonzero element remains in the first column, or until the table collapses. The final row provides the last condition.
Check the conditions: For stability, the following must hold:
- D(1) > 0
- (–1)ⁿ D(–1) > 0
- For the Jury table, the first element of each odd-numbered row (rows 1, 3, 5, …) must be greater than zero. Equivalent conditions involve the leading entries of the reduced polynomials.

These conditions together are necessary and sufficient for all roots to satisfy |z| < 1. In practice, the test is implemented in computer algebra systems, but the manual process is manageable for orders up to about 4 or 5.

Example: Second-Order System

Consider a second-order discrete system with characteristic polynomial D(z) = z² + a₁z + a₂ = 0. Applying Jury’s test:

Row 0: 1, a₁, a₂
Row 1: a₂, a₁, 1
Row 2: The next row has entries b₀ = 1 – a₂², b₁ = a₁ – a₁a₂

Stability conditions for second-order:

D(1) = 1 + a₁ + a₂ > 0
(–1)² D(–1) = 1 – a₁ + a₂ > 0
| a₂ | < 1

These are the familiar conditions for a stable second-order discrete system. Notice that Jury’s test directly yields these simple inequalities without any transformation.

Advantages of Jury’s Test

Direct application: Works on the z-domain polynomial; no mapping required.
Complete set of conditions: Provides both necessary and sufficient stability criteria.
Handles special cases: Includes checks for roots on the unit circle (marginal stability) through the D(1) and D(–1) conditions.
Suitable for digital implementation: The table construction is algorithmic and easily programmed.

Head-to-Head Comparison of Routh-Hurwitz and Jury’s Stability Test

Aspect	Routh-Hurwitz (Adapted)	Jury’s Stability Test
Domain	Continuous (s-plane) originally; adapted via bilinear transform to w-plane	Discrete (z-plane) directly
Stability region	Left-half plane (after transformation, maps to inside unit circle)	Inside unit circle (\|z\|<1)
Procedure	Construct Routh array from w-polynomial; check sign of first column	Construct Jury table from z-polynomial; check series of inequalities
Complexity	Moderate after transformation; transformation adds extra algebraic steps	Low to moderate; table construction straightforward for low to medium orders
Numerical stability	Can suffer from coefficient scaling after bilinear transform	Generally good; determinants may cause swelling for high orders
Handling of marginal stability	Auxiliary polynomial required; roots on imaginary axis in w-plane	Direct checks through D(1) and D(-1) conditions
Educational accessibility	Students often learn continuous version first; adaptation extends existing knowledge	Requires understanding of unit circle concept; but method is self-contained
Software implementation	Easily coded via array construction; bilinear transform may require symbolic toolbox	Easily coded via recursive table; native to z-domain
Typical use case	When system is already in s-domain or hybrid continuous/discrete	When characteristic polynomial is directly from a discrete transfer function

Detailed Comparison Points

1. Applicability and Domain Fit

Jury’s test is the natural choice for pure discrete systems, especially in digital control applications where the controller output and plant input are sampled. Routh-Hurwitz requires a transformation that adds complexity and may obscure the physical interpretation of poles relative to the unit circle. Many modern textbooks and courses on digital control present Jury’s test as the standard tool.

2. Algebraic Complexity

For orders up to 4 or 5, both methods are manageable by hand. However, Jury’s test avoids the bilinear expansion, which can produce terms with mixed powers and large coefficients. For example, a third-order D(z) transformed to w yields a third-order polynomial itself, but the coefficients are combinations of the original ones; for higher orders, the transformation becomes more laborious. Jury’s table construction, while involving determinants, operates directly on the original coefficients.

3. Numerical Robustness

Routh-Hurwitz in the w-domain can suffer from ill-conditioning if the bilinear transformation creates coefficients with very different magnitudes. Jury’s test also faces numerical issues for high-order polynomials (e.g., order > 10) due to repeated subtractions and determinant calculations, but these are less severe than those introduced by the transformation. Both methods benefit from double-precision implementation in software.

4. Ability to Determine Number of Unstable Poles

Routh-Hurwitz, by virtue of the Routh array’s sign changes, can directly indicate the number of poles in the right-half w-plane, which corresponds to the number of poles outside the unit circle. Jury’s test, in its basic form, provides a yes/no stability answer. However, extensions of Jury’s test (e.g., the Jury-Gantmacher algorithm) can also count the number of roots outside the unit circle, though this is less commonly taught.

5. Handling of Special Polynomial Coefficients

When a discrete system has zero coefficients (missing powers), both methods require caution. Routh-Hurwitz deals with zero entries in the array by using small epsilon approximations. Jury’s test similarly needs to manage zeros during table construction, but the algorithm remains valid as long as the leading coefficient a₀ is nonzero. If a row in the Jury table becomes entirely zero, the polynomial has symmetric roots indicating marginal stability or anti-symmetry.

Practical Applications and When to Choose Each Method

Use Jury’s Test When

You are working exclusively in the discrete domain (z-plane).
You want a one-step test without domain transformations.
You are analyzing a digital controller or a sampled-data system with a known sampling period.
You need clear conditions for marginal stability (roots on the unit circle).
The polynomial order is moderate (≤ 8 for manual checks; higher for software).

Use Routh-Hurwitz (via Bilinear Transform) When

Your control system design is already in the continuous domain and you are discretizing later.
You prefer a unified analysis framework for both continuous and discrete systems.
You have software (e.g., MATLAB, Python with SymPy) to handle the bilinear transform automatically.
You need to count the exact number of unstable poles (via sign changes in the Routh array).
You are teaching the link between continuous and discrete stability criteria.

Real-World Examples

Example: Digital motor speed controller. A microcontroller implements a PI controller for a DC motor. The closed-loop characteristic polynomial is derived in the z-domain. An engineer would use Jury’s test to check stability for various sampling rates and proportional gains. The test quickly reveals whether the poles move outside the unit circle as gain increases.

Example: Adaptive filter design. In signal processing, IIR filters require poles inside the unit circle to avoid self-oscillation. Jury’s test is commonly embedded in filter design libraries to validate stability after coefficient quantization.

Example: Hybrid continuous-discrete system. A continuous plant controlled by a digital compensator requires discretization via a zero-order hold. The overall characteristic equation in the z-domain can be analyzed either by Jury’s test directly or by using the bilinear transform to apply Routh-Hurwitz. Many control engineers prefer Jury’s test because they can stay in the z-domain and avoid additional transforms.

Software Implementation and Automation

Both methods are available in control system toolboxes. For instance:

MATLAB: The function routh (or custom scripts) can build the Routh array, while jury is available in the Robotics Toolbox or can be programmed. The function c2d performs discretization and bilinear transform if needed.
Python (SciPy and control libraries): The control library includes justice() for Jury’s test. For Routh-Hurwitz, the stability_margin function or manual array construction is used.
Symbolic tools: SymPy and Mathematica allow algebraic manipulation for the bilinear transform and subsequent array generation.

When using software, the transformation step for Routh-Hurwitz is automated, reducing manual error. However, for rapid prototyping of discrete systems, Jury’s test remains the more direct choice.

Limitations and Caveats

Neither method is a panacea. Both become unwieldy for high-order polynomials (order > 10) due to accumulation of numerical errors. For such cases, computational root-finding (e.g., eigenvalue methods) is often more reliable. Additionally, both tests assume the characteristic polynomial is known exactly; modeling uncertainties and parameter variations require robust stability analysis beyond these algebraic criteria.

Another important caveat: the Routh-Hurwitz adaptation via bilinear transform is valid only for linear time-invariant systems. It does not directly extend to time-varying or nonlinear discrete systems. Jury’s test similarly applies only to linear discrete models.

Finally, misinterpretation of the conditions can occur. For Jury’s test, the condition D(1) > 0 and (–1)ⁿD(–1) > 0 are necessary but not sufficient alone; they must be combined with the table conditions. Students sometimes stop after these two simple checks, which can lead to incorrect stability conclusions for higher-order systems.

Conclusion

Choosing between Routh-Hurwitz and Jury’s stability test for discrete systems depends on context, familiarity, and computational resources. Jury’s test is the more direct, purpose-built method for discrete-time polynomials, offering clear conditions and avoiding the bilinear transformation. The adapted Routh-Hurwitz criterion provides a bridge for engineers trained in continuous systems and can be useful when integrating continuous and discrete analyses. Both methods remain valuable educational tools that reinforce the fundamental concept of pole location relative to the unit circle.

For most modern digital control design and discrete system analysis, Jury’s stability test is the recommended approach. However, proficiency in both techniques ensures that the engineer can adapt to various problem statements and leverage available software to verify results. Understanding the strengths and weaknesses of each method empowers designers to make informed decisions, ultimately leading to more robust and reliable control systems.