Implementation Of Modified Jury Stability Test English Language Essay
transform is a commonly used tool for analyzing discrete – time control systems. It plays similar role as Laplace transform for continuous – time systems.
To describe the dynamics of linear discrete – time control systems we use difference equation. If some signal is applied on the input, we need to solve such a difference equation to determine system’s response. With the Z – transform method we solve algebraic equations to derive Z transform of the response instead of solving the linear difference equations.
While considering transform of a time function , we focus only on sampled values of , that is , , , … where is a sampling period.
Therefore the transform of the function or of the sequence of values where k is an integer ≥0 and T is a sampling period, is described by the following equation [1]:
(1.1)
1.2 Definition of the linear dicrete-time dynamical system
Discrete – Time System can be described not only by a linear difference equation but also transfer function, or state space model.
Transfer function of the discrete system is the ratio between the Z-transforms of response and excitation under zero initial conditions:
(1.2)
It is also the Z – transform of the impulse response of the system. The input signal (an impulse) is given by the function:
(1.3)
Applying Z- transform to the input signal, then, using the equation (1.2) we obtain:
(1.4)
(1.5)
State space equations for the discrete -time, time invariant systems are formulated as :
(1.6)
where is the internal state, control input, and measured output [5]:
,
If we apply Z – transform to equations (1.6) we can obtain transfer function of the system. Therefore:
(1.7)
Figure 1. State space model
Transfer function poles are the roots of the characteristic polynomial which is the denominator of the transfer function. What is more every pole of is an eigenvalue of the system matrix A. Though, not every eigenvalue of A is a pole of .
1.3 Stability of Discrete – Time systems.
Stability of the system is the ability of the system to come back to the equilibrium after the excitation signal is removed.[4] In other words, system is stable if its impulse response approaches zero while time goes to infinity.
As it was mentioned, Z transform of the impulse response is a transfer function of the discrete system. Therefore to examine the relationship between impulse response and poles of the system we need to transform transfer function into a time domain using a residue theorem.
(1.8)
As we see inverse Z – transform of the impulse response is a sum of the residue of
Where, for a simple pole:
(1.9)
As we see the impulse response is a sum of components containing factors Cpin-1 . Such factor will tend to zero with increasing n if and only if . The formal proof covering also the case of multiple poles may be found for example in [1]. Similar conclusion may be derived from modal form of state response of system (1.6) [1]: the system is stable if and only if all eigenvalues of state matrix A are inside the unit circle on the complex plane.
Testing the stability of the discrete – time systems is done by checking if the roots of the characteristic polynomial (i.e denominator of the transfer function or characteristic polynomial of state matrix A) are inside of the unit circle on the Z-plane.
– characteristic polynomial (1.10)
Figure 2. Stability property areas on the Z-plane
In the past, when numerical methods were not as effective as nowadays, people thought of number of criterias that enabled them to conclude whether the system is stable or unstable. We can divide the aforementioned methods into two groups:
Using the equation to transform Z plane into S plane. After transforming characteristic polynomial of the discrete system form z – domain into s – domain we can examine the equation by the methods that are applied to the continuous – time systems: like Routh – Hurwitz criterion
Algebraic tests, that are dedicated to discrete time domain like Marden or Jury test. The latter, will be meticulously described in my thesis.
Jury stability test
2.1 Eliahu I. Jury
Professor Eliahu Ibrahim Jury was born on May 23, 1923 in Bagdad. After finishing secondary school he left Iraq and started studying economy and philosophy at the American University of Beirut. Afterwards, he decided to study electrical engineering at Hebrew Technical College. Shortly, after receiving his diplome engineer degree he decided to go to United States to study at Harvard University, where he was awarded his last M.S degree. His Sc. D. degree (which stands for Doctor of science) he obtained at Columbia Uniersity in New York. During his stay at Columbia Univeristy he was mostly concerned with Sampled-Data Systems. In 1954 he joined the University of California to work as an instructor in the Department of Electrical Engineering and Computer Sciences. Ten years later he was appointed a professor.
Time spent at University of California was described by himself as a “breakthrough in academic career”. He formulated Jury stability table, which anable to study the roots distribution of the polynomial without solving it explicitly. He also wrote a book “Theory and Application of the z-Transform Method” that has a huge impact on the area of discrere – time systems.
In 1981 prof. Jury moved with his family to Miami where he started working in the local University. He continued his working on two and more dimensional discrete systems (2 -D and m – D). It is also where he lives till today. [2]
2.2 Stability Criterion by the Jury Test
Jury stability test allows us to study distributiont of the roots of the polynomial without solving the polynomial explicitly. It was formulated in 1964. Several mutations of Jury test are reported in the literature, however in this work I will concentrate on the formulation given in [6]
Let the characteristic equation be as follows:
(2.1)
Assuming that:
Polynomial M(z) has real coefficients
M(z) does not have a Root on the unit circle
We construct the table according to the following equations:
(2.2)
Let describe respectively number of roots of the polynomial M(z) inside and outside of the unit circle. Also, let and denote the number of positive and negative elements elements from the numbers in first column
Assume that all the elements in the first column are different from zero.
If , then:
(2.3)
If then:
(2.4)
2.3 Singular cases
Though Jury stability test allows us to said whether the system is stable or not (without finding the roots of characteristic polynomial) we may face some problems.
Problem 1 : A row consisting of zeros and premature termination
Problem 2: Row with the first element equal to zero
The Jury test is not directly applicable to such singular cases unless some modifications are made.
Proof of Jury Stability Test
There are a couple of proves of Jury Stability Test. Nevertheless, in this thesis we will focus only on two of them. First one, was formulated by L.H Keel and S.P Bhattacharyya from United States. Second, was created in 2010 by Yousenok Chao from Honkong University.
3.1 Proof 1
That proof is based on the simplified table created by Raible. It is conducted using the induction . Therefore for the characteristic polynomial:
(3.1)
Raible’s table looks as follows:
P(z):
Q(z):
R(z):
T(z):
U(z):
V(z):
Where each row of the Raible’s table represents a polynomial (3.1). To check the stability of the system we check the sign of the first element of each row.
Proof:
1. Let us consider the case when the degree of polynomial is: n=1. Let :
(3.2)
be a test polynomial. We create Jury’s table:
(3.3)
a) Assume first that and . We need to prove that:
(3.4)
From the equation (3.3) we infer that Therefore:
=1 and =0 (3.5)
On the other hand we know that:
(3.6)
Therefore:
(3.7)
b) Now suppose that and . Then, from the construction of the Raible’s table . Therefore:
=0 , and =1 (3.8)
(3.9)
So:
(3.10)
We can also show that the theorem is true for the cases:
,
and
, .
Now let us assume that the theorem is true for all the polynomials of the degree (n-1)
If (3.11)
We will consider four cases:
a) If and then we have . As no change in sign appears:
. (3.12)
As Q(z) is of degree (n-1) and and since we obtain:
(3.13)
(3.14)
As and as Q(z) is of degree (n-1):
(3.15)
and since we have:
(3.16)
Therefore:
(3.17)
We can prove it similarly for the other cases:
b) and ,
c) and
d) <and
And summing everything up we will obtain:
If then
If then
Therefore the Theorem holds for polynomials of degree „n” and the proof is complete. [6]
Proof 2
That proof is based on the original Jury Stability Test. Considering that, construction of the Jury table differs from the one presented in proof 1. As in the previous proof only regular cases are considered.
Assuming that:
(3.18)
is a characteristic polynomial of n’th order. We construct the stability table as follows:
It is clearly visible that it differs from the Raible’s table. Second row consist of the elements with reversed sign.
Where:
(3.19)
etc (3.20)
and then:
(3.21)
Assume that:
(3.22)
Then, system is stable if and only if:
(3.23)
(3.24)
Then as in the previous proof we show that the number of positive and negative elements from is also the number of the roots inside and outside of the unit circle.
3.3 Comparing both ways of proving the Jury Stability Test
As far as I am concerned, the first proof is easier to understand. It is because Keel and Bhattacharyya proof relies on Raible’s simplified table – it is not carried directly from the original form of Jury test.
What is more, authors of proof 2 are using top and bottom index to mark each element of the table which makes their proof less clear.
4. Existing Matlab implementations of Jury Stability Test
4.1 Implementation 1
First implementation is a function named “Jury”. It was created by Jonathan Epperlein 8th of February 2007.
The procedure expects user to define vector of coefficients of the examined polynomial. Then, by applying “jury” function to the vector, we obtain Chun’s table (table with the inversed rows). Function created by Jonathan Epperlein does not give us an answer how many of roots are inside and outside of the unit circle. It assumes that user knows how the table is constructed and knows the rule of negative and positive elements. If not, one can use function’s help that explains how it works.
Function takes into account the case when the system is critically stable which means that one of the roots is on the unit circle. If so, it displays error message.
To sum it up, I think that function “Jury” should be modified for the use of the layman. The command of showing number of roots inside and outside of the unit circle needs to be added. Nevertheless, program works properly, and the result it gives agrees with the result given by the built-in Matlab function “roots”.
4.2 Implementation 2
The second implementation was created by Carlos Mario Velez Sanchez in 2011. As in the previous case it is based on Chun’s table and it expects the user to enter vector of the coefficients. What is different, is that it includes special cases:
when the first element of the second row (not inversed) is equal to zero
when row of zeros appears (when there are roots on the unit circle or reciprocal roots like ‘r’ and ‘1/r’
Unfortunately when tested, program does not seem to include singular cases. As long as there were no zero entries to the row, program worked properly. When entering polynomial with root on the unit circle, function does not create a proper table.
As in the former function, that one also does not give the user explicit answer considering number of roots inside and outside of the circle. The result of the function is a table that the user should interpret on their own.
5. My own implementation of Jury Criterion
5.1 Basic information
In my own implementation of the Jury test I am using Raible’s simplified table. Unfortunately, I am not dealing with the singular cases. Therefore, if they appear, my program stops and displays a message about the appearance of the singular case. The result of the program is information about the amount of roots inside and outside of the unit circle (depending on the sign of the highest coefficient) with the evaluation of system’s stability. I made an assumption that there would be no roots on the unit circle.
5.2 Program structure
My program is a function, that takes as an input vector of coefficients. On the output of the function we obtain Raible’s table and the vector of numbers from the first column of the Raible’s table. As it was explained in the earlier chapters, they are needed to conclude whether the system is stable or not.
function [ table, Z ] = Jury_test( A )
elements=length(A);
degree=elements-1;
table=zeros(elements);
table(1,:)=A;
n=elements;
d=1;
Then I am formulating Raible’s table. First of all, I am creating an empty matrix of zeros of the dimensions : . Secondly, we create an ‘inversed’ vector. In other words it’s a vector where elements are in the inversed order. Then, coefficient ‘k’ is calculated which stays constant for each row. Coefficient ‘k’ can be defined as a ratio between the last element of a previous row and first element of a previous row. Finally each element of the row is computed according to equations (2.2) If the first element of a row is equal to 0, program stops and the message is displayed.
for i=2:elements
A_inv=A(n:-1:1);
k=A(n)/A(1);
B=A(1:n)-k*A_inv(1:n);
%additional loop to fill not used part of the table with zeros
for x=1:d
B(elements+1-x)=0;
x=x+1;
end
table(i,:)=B; % Pushing the computed vector into a table
if B(1)~=0 % If there is no zero entrance in the table
d=d+1;
i=i+1;
n=n-1;
A=B;
else %zero entrance in the table
disp(‘Singular case. The program ends’)
return
end
end
The last stage of the program is concluding how many of elements are inside and outside of the unit circle. To do so, I created vector ‘Z’ that consists of the first elements of each row of the Raible’s table. Then I checked the sign of the elements and counted down positive and negative numbers.
Z=table(2:degree+1,1);
Z;
%creating vectors consisting of 0&1 where 1->positive number, 0->negative number
positive=Z>0;
pos=sum(positive);
negative=Z<0;
neg=sum(negative);
if A(1)>0
disp(‘Number of poles inside of the unit circle’);
disp(pos);
disp(‘Number of poles outside of the unit circle’);
disp(neg);
if any(Z(:)<0)
disp (‘System is unstable’)
return
if all(Z(:)>0)
disp(‘System is stable’)
return
end
end
end
if A(1)<0
disp(‘Number of poles inside of the unit circle’);
disp(neg);
disp(‘Number of poles outside of the unit circle’);
disp(pos);
if any(Z(:)>0)
disp (‘System is unstable’)
return
if all(Z(:)<0)
disp(‘System is stable’)
return
end
end
end
5.3 Comparison with previous Matlab implementations of Jury test
First of all, my implementation is based on the simplified Raibles table, while other two use Chun’s one. I was trying to make my file more “user friendly” by not only displaying the table, but also number of roots inside and outside of the unit circle. Even if one does not know how Jury test works and what requirements must be fulfilled by the system to be stable, they can still used my program and obtain the answer.
6. Comparing effectiveness of Jury test and roots method for particular polynomials
It seems obvious that instead of using Jury stability test we may find roots of the characteristic polynomial and determine if they are inside or outside of the unit circle. That method does not require prior assumption about no roots on the unit circle. It is also no affected by singular cases that make Jury test more complicated.
On the other hand it is known that procedures for finding roots of the polynomials might give a results with a considerable error. Especially while testing the polynomials of high degree, or
polynomial with a multiple roots or roots located close to each other. In case of roots lying close to the unit circle, they might be wrongly classified as stable or unstable.
In this chapter we will compare the effects of using Jury stability test implemented by a function shown in chapter 5 and built – in functions available in Matlab.
6.1 Build- in function “roots”
As Matlab is intended primarily for numerical computing it has couple of functions for finding roots of the polynomial. The basic function for finding the roots of the polynomial is ROOTS. The input of that procedure is a vector of coefficients, given by a user.
Syntax:
r = roots(C)
Where C is a vector of coefficients
The output of the function is a column or row vector that consists of the roots of the polynomial C.
The algorithm of the function is computing the eigenvalues of the companion matrix :
A = diag(ones(n-1,1),-1);
A(1,:) = -C(2:n+1)./C(1);
eig(A)
The results of the aforementioned algorithm are the exacts eigenvalues of the matrix within roundoff error of the companion matrix A. However, they are not the exact roots of a polynomial with coefficients within roundoff error of those in vector C. [12]
6.2 Comparing “roots” and Jury stability test for polynomials
In this section we will compare results of each procedure for the polynomials in a form of , where is a really small number. As we can infer, the roots of that polynomial will be located on the circle of the radius , therefore in the unit circle.
Assuming that we propose the following testing procedure:
Testing root procedure:
figure
xlabel(‘n – poly degree’)
ylabel(‘-m – eps=10^-m’)
hold on
for n=2:70
for m=1:1:20
if sum(abs(roots([1 zeros(1,n-1) 1-10^-m]))<1)==n
plot(n,-m,’g*’)
else
plot(n,-m,’r*’)
end
end
end
hold off
Figure 3. The result of testing roots procedure
Green points are those pairs (n, -m) for which the classification of the polynomial (stable or unstable) is correct. As we can see on the Figure 3, for ‘m’ higher than 12 roots procedure starts to compute the roots of the polynomial wrongly.
Testing Jury stability test
figure
xlabel(‘n – poly degree’)
ylabel(‘-m – eps=10^-m’)
hold on
for n=2:70
for m=1:1:20
A=[1 zeros(1,n-1) 1-10^-m];
(…) -> here Jury_test is applied
if sum(Z>0)==n
plot(n,-m,’g*’)
else
plot(n,-m,’r*’)
end
end
end
hold off
Figure 4. The result of testing Jury stability test
After comparing those two ways of evaluating stability of the systems we see that Jury stability criterion works better for the high degree polynomials. What is more it is more accurate. It starts to be mistaken about the stability of the system when epsilon is around while roots method can be wrong even for (for a high degree polynomials)
6.3 Comparing “roots” and Jury stability test for polynomials
In this section we will see what resultants give each procedure for the polynomials in a form of , where is, as in the previous section, a really small number. The roots of that polynomial will be doubled and located on the circle of the radius , therefore in the unit circle.
Assuming that
Testing root procedure:
figure
xlabel(‘n – poly degree’)
ylabel(‘-m – eps=10^-m’)
hold on
for n=2:35
for m=1:1:20
eps=10^-m;
z=abs(roots([1 zeros(1,n-1) -2*(1-eps) zeros(1,n-1) (1-eps)^2]));
if (sum(z<1)==2*n )
plot(n,-m,’g*’)
else
plot(n,-m,’r*’)
end
end
end
hold off
Figure 5. The result of the roots method
As we can see on the Figure 5, the results have deteriorated. The area in which roots procedure gives the correct answer is smaller.
Testing Jury stability test
figure
xlabel(‘n – poly degree’)
ylabel(‘-m – eps=10^-m’)
hold on
for n=2:35
for m=1:1:20
eps=10^-m;
A=[1 zeros(1,n-1) -2*(1-eps) zeros(1,n-1) (1-eps)^2];
(…) -> here Jury_test is applied
if (sum(Z>0)==2*n )
plot(n,-m,’g*’)
else
plot(n,-m,’r*’)
end
end
end
hold off
Figure 6. The result of the Jury stability test
In case of the Jury stability test the results have deteriorated even more significantly. For the double roots on the circle of the radius roots method turns out to be more accurate. The answer about stability is correct until and for the lower degree of polynomial even for while Jury stability test is mistaken for the .
6.4 Testing “roots” and Jury stability test for Chebyshev polynomials
Chebyshev polynomials, are polynomials that coefficients are given by the recurrence relation:
(6.1)
Chebyshev polynomials are used mainly in approximation theory. The roots of the Chebyshev polynomials of the first kind, are used in polynomial interpolation.
What is more, Chebyshev polynomial of the degree n, has n different simple roots. They are located in the interval [-1,1].
For testing the efficiency of the “roots” and Jury_test functions for Chebyshev polynomials we will use too additional functions found on MathWorks: Chebyshevpoly.m, Chebyshevroots.m. First was written by David Terr in 2004. It is used to calculate the coefficients of the Chebyshev polynomial of the degree “n”. The second one was created by Russell Francis and it is used to calculate the roots of the Chebyshev polynomial of the degree “n”. We will use it to check the proper roots of Chebyshev polynomial and see how much they differ firm the one computed by roots.
Testing was conducted in a similar way as in chapter 6.4. Green star means that root procedure is working properly, red one indicates the error.
Testing root procedure:
figure
xlabel(‘n – poly degree’)
hold on
for n=2:70
tkm2 = zeros(n+1,1);
tkm2(n+1) = 1;
tkm1 = zeros(n+1,1);
tkm1(n) = 1;
for k=2:n
tk = zeros(n+1,1);
for e=n-k+1:2:n
tk(e) = 2*tkm1(e+1) – tkm2(e);
end
if mod(k,2)==0
tk(n+1) = (-1)^(k/2);
end
if k<n
tkm2 = tkm1;
tkm1 = tk;
end
tk
end
z=abs(roots(tk));
if (sum(z<1)==n )
plot(n,1,’g*’)
else
plot(n,1,’r*’)
end
end
Figure 7. Efficiency of roots procedure for Chebyshev polynomials: 1 means correct, 0 means erroneous
Testing Jury stability test:
figure
xlabel(‘n – poly degree’)
title(‘Testing “Jury_test” function’)
hold on
for n=2:70
tkm2 = zeros(n+1,1);
tkm2(n+1) = 1;
tkm1 = zeros(n+1,1);
tkm1(n) = 1;
for k=2:n
tk = zeros(n+1,1);
for e=n-k+1:2:n
tk(e) = 2*tkm1(e+1) – tkm2(e);
end
if mod(k,2)==0
tk(n+1) = (-1)^(k/2);
end
if k<n
tkm2 = tkm1;
tkm1 = tk;
end
A=tk;
end
%%%%%%%%%%%%%%%%%
<- here Jury_test is applied
%%%%%%%%%%%%%%%%%%%
if (sum(Z>0)==n)
plot(n,1,’g*’)
else
plot(n,1,’r*’)
end
Z=0;
A=0;
B=0;
nn=0;
end
hold off
Figure 8. Efficiency of Jury_test procedure for Chebyshev polynomials: 1 means correct, 0 means erroneous
At first sight there is no difference between roots procedure and Jury stability test, but if we look closely, the results of aforementioned functions differ for the polynomials of the degree around 45. For a Chebyshev polynomial of the degree 42 roots procedure is making an error, while Jury test is still acting properly:
Figure 9. The result of roots and Jury test procedure for Chebyshev Polynomial of degree 42
But for a Chebyshev polynomial of a degree 43:
Figure 10. The result of roots and Jury test procedure for Chebyshev Polynomial of degree 43
As we can see in the Figures 7, 8, 9 and 10, the result of the Jury stability test and roots procedure are roughly the same.
6.5 Comparing processing time for “roots” and Jury stability test.
The following test should give the answer about how much time is require to compute the roots of the polynomial with random coefficients. It is computed in a function of the degree of the polynomial. To do so we will use the procedures tic and toc.
Tic and toc procedures work together to measure elapsed time. Tic saves the current time, which is used later by the procedure toc to evaluate how much time has passed. [12]
Testing root procedure:
time=[];
nn=[];
for n=10:10:200
nn=[nn n];
loctime=0;
tic
for i=1:10
p=rand(1,n+1);
z=abs(roots(p));
inside_num=sum(z<1);
loctime=loctime+toc;
end
time=[time,loctime/10];
end
plot(nn,time,’*’)
xlabel(‘n’)
ylabel(‘evaluation time’)
Figure 11. Time consumed by roots method
Testing Jury stability test
time=[];
nn=[];
for n=10:10:200
nn=[nn n];
loctime=0;
tic
for i=1:10
p=rand(1,n+1);
A=[p];
(…)-> here Jury_test is applied
inside_num=sum(Z>0);
loctime=loctime+toc;
end
time=[time,loctime/10];
end
plot(nn,time,’*’)
xlabel(‘n’)
ylabel(‘evaluation time’)
Figure 12. Time consumed by Jury criterion
Comparing those two methods we can see that Matlab is realizing faster Jury stability criterion. For instance for the polynomial of the degree 200 Jury stability test needs less than 0.03 second, while roots method requires 0.65 second. So around 20 times more.
The result seems logic, as Jury stability criterion is not computing the roots itself but only the location of roots according to the unit circle.
7. Additional program functions – checking robust stability by Jury test
While evaluating discrete – system’s stability it is important not only to check whether the roots are in the unit circle but also their distribution in the in circle with arbitrary radius. That lets us to measure stability robustness as well as evaluate how fast the transient component of system’s response disappear.
That is why I wrote an external procedure that asks the user not only to give coefficient of the characteristic polynomial, but also 3 radius – (preferably inside of the unit circle). Function “radius” gives us an answer about the distribution of the roots inside of the rings:
(7.1)
Figure 13. Checking the amount of roots in particular rings
The aforementioned program uses Jury_test function, which is applied to the appropriately calibrated polynomial. Calibration depends on the radius in which we are checking.
Function ‘radius’ has four input arguments: vector A with coefficients of the examined polynomial and three radiuses. Radius should be entered form biggest to lowest. The output of the function gives us the information about the stability of the system as well as the information about the root distribution.
function [table, Z] = radius( A, r1, r2, r3 )
Firstly Jury_test is applied to the polynomial with coefficients in matrix A and program determines system’s stability. Secondly, polynomial’s coefficients are calibrated to check the existence of the roots in a circle of radius .
n=elements;
scale=n;
for i=1:1:elements
BB(i)=M(i)*r1^scale ;
scale=scale-1;
end
Where M is additional matrix which has the same coefficients as matrix A. Matrix A is not used here as it was transformed in some previous operations. Afterwards Jury_test is applied to new, calibrated matrix BB. Similar code was created to circles of radius and .
positive1=Z1>0;
pos1=sum(positive1);
negative1=Z1<0;
neg1=sum(negative1);
Amount of roots inside and outside of the circle are described by variables pos1 and neg1. Similarly, variables pos2, neg2 and pos3 neg3 determine amount of zeros inside and outside of circles of radius and .
At the end of the function we calculate amount of roots in rings between particular circles and present the result (taking into account the sign of the highest coefficient of matrix A=M)
ring1=pos2-pos3;
ring2=pos1-pos2;
ring3=pos-pos1;
ring11=neg2-neg3;
ring22=neg1-neg2;
ring33=neg-neg1;
if M(1)>0
disp(‘Amount of roots inside of the circle of radius r3 is:’)
disp(pos3);
disp(‘Amount of roots inside of the ring between r2 and r3 is:’)
disp(ring1);
disp(‘Amount of roots inside of the ring between r1 and r2 is:’)
disp(ring2);
disp(‘Amount of roots inside of the ring between UNIT CIRCLE (r=1) and r1 is::’)
disp(ring3);
end
if M(1)<0
disp(‘Amount of roots inside of the circle of radius r3 is:’)
disp(neg3);
disp(‘Amount of roots inside of the ring between r2 and r3 is:’)
disp(ring11);
disp(‘Amount of roots inside of the ring between r1 and r2 is:’)
disp(ring22);
disp(‘Amount of roots inside of the ring between UNIT CIRCLE (r=1) and r1 is:’)
disp(ring33);
end
Example
Let’s consider an example to check how the ‘radius.m’ procedure is working. Assume that examined polynomial looks as follows:
(7.2)
Roots of the polynomial above are:
We would like to check the distribution of roots. Therefore we describe three circles of the radius:
First part of the radius procedure is similar to the “Jury_test.m”. Program gives back the answer about the stability of the system, as well as Raible’s table. Then we obtain the answer about the distribution of the roots inside of the circles of given radius.
The output of the “radius.m” procedure for our example polynomial can be seen on figure 14 and 15. On the figure 16, we can see that program is working properly. There is one root inside of the circle of the radius (), one root between circles and (), one root between circles and () and finally one root between and unit circle ().
Figure 14. Result of the “radius.m” procedure
Figure 15. Results of “radius.m” procedure for given radius
Figure 16. The distribution of the roots in the given circles
8. Conclusions
The aim of this thesis was mainly to evaluate the effectiveness of Jury stability test for discrete – time systems in times when numerical methods are highly developed.
Taking into account conducted tests for polynomials and Chebyshev polynomials, Jury_test procedure is more accurate than in – built Matlab function roots. What is more, the processing time of the former is around 20 times shorter than processing time of the latter procedure. Therefore we can infer that Jury test has some advantages over roots method.
However, for the polynomials , that have doubled roots, roots procedure is more correct than Jury test.
We should also bear in mind that Jury test doesn’t give us the answer about the exact roots of the system. It is used only to check whether the roots are inside or outside of the unit circle. What is more, it fails when singular cases are considered. After adding some additional features we can evaluate if roots are located in the arbitrary circle. Therefore it enables us to examine how far from the unit circle they are located and measure stability robustness. That kind of improvement makes program suitable for more application where time is a significant factor and user needs only the answer whether discrete – time system is stable or not. Nevertheless, while designing the system we need to know accurate roots of the system.
To sum it up Jury_test is a fast and accurate tool to determine the stability of the system. However, in majority of automatic control application we need exact roots of the discrete – time system. In times when numerical methods were not as developed as now, it was a useful tool, but now, the usage of algebraic stability test has shrunk.
Order Now