def row_proper(A):
"""
Reduction of a polynomial matrix to row proper polynomial matrix
Implementation of the algorithm as shown in page 7 of
Vardulakis, A.I.G. (Antonis I.G). Linear Multivariable Control: Algebraic Analysis and Synthesis Methods.
Chichester,New York,Brisbane,Toronto,Singapore: John Wiley & Sons, 1991.
INPUT:
Polynomial Matrix A
OUTPUT:
T:An equivalent matrix in row proper form
TL the unimodular transformation matrix
Christos Tsolakis
Example: TODO
T=Matrix([[1, s**2, 0], [0, s, 1]])
is_row_proper(T)
see also Wolovich Linear Multivariable Systems Springer
"""
T=A.copy()
Transfomation_Matrix=eye(T.rows) #initialize transformation matrix
while not is_row_proper(T):
#for i in range(3):
Thr=mc.highest_row_degree_matrix(T,s)
#pprint(Thr)
x=symbols('x0:%d'%(Thr.rows+1))
Thr=Thr.transpose()
Thr0=Thr.col_insert(Thr.cols,zeros(Thr.rows,1))
SOL=solve_linear_system(Thr0,*x) # solve the system
a=Matrix(x)
D={var:1 for var in x if var not in SOL.keys()} # put free variables equal to 1
D.update({var:SOL[var].subs(D) for var in x if var in SOL.keys()})
a=a.subs(D)
r0=mc.find_degree(T,s)
row_degrees=mc.row_degrees(T,s)
i0=row_degrees.index(max(row_degrees))
ast=Matrix(1,T.rows,[a[i]*s**(r0-row_degrees[i]) for i in range(T.rows)])
#pprint (ast)
TL=eye(T.rows)
TL[i0*TL.cols]=ast
#pprint (TL)
T=TL*T
T.simplify()
Transfomation_Matrix=TL*Transfomation_Matrix
Transfomation_Matrix.simplify()
#pprint (T)
#print('----------------------------')
return Transfomation_Matrix,T
def ALGO4(As,Bs,Cs,Ds,do_test):
#-------------------STEP 1------------------------------
if not is_row_proper(As):
Us,Ast=row_proper(As)
else:
Us,Ast=eye(As.rows),As
Bst=Us*Bs
Bst=expand(Bst)
r=Ast.cols
#-------------------STEP 2------------------------------
K=simplify(Ast.inv()*Bst) #very important
Ys=zeros(K.shape)
for i,j in product(range(K.rows),range(K.cols)):
Ys[i,j],q=div(numer(K[i,j]),denom(K[i,j]))
B_hat=Bst-Ast*Ys
#-------------------END STEP 2------------------------------
#-------------------STEP 3------------------------------
Psi=diag(*[[s**( mc.row_degrees(Ast,s)[j] -i -1) for i in range( mc.row_degrees(Ast,s)[j])] for j in range(r)]).T
S=diag(*[s**(rho) for rho in mc.row_degrees(Ast,s)])
Ahr=mc.highest_row_degree_matrix(Ast,s)
Help=Ast-S*Ahr
SOL={}
numvar=Psi.rows*Psi.cols
alr=symbols('a0:%d'%numvar)
Alr=Matrix(Psi.cols,Psi.rows,alr)
RHS=Psi*Alr
for i,j in product(range(Help.rows),range(Help.cols)): #diagonal explain later
SOL.update(solve_undetermined_coeffs(Eq(Help[i,j],RHS[i,j]),alr,s))
Alr=Alr.subs(SOL) #substitute(SOL)
Aoc=Matrix(BlockDiagMatrix(*[Matrix(rho, rho, lambda i,j: KroneckerDelta(i+1,j))for rho in mc.row_degrees(Ast,s)]))
Boc=eye(sum(mc.row_degrees(Ast,s)))
Coc=Matrix(BlockDiagMatrix(*[SparseMatrix(1,rho,{(x,0):1 if x==0 else 0 for x in range(rho)}) for rho in mc.row_degrees(Ast,s)]))
A0=Aoc-Alr*Ahr.inv()*Matrix(Coc)
C0=Ahr.inv()*Coc
SOL={}
numvar=Psi.cols*Bst.cols
b0=symbols('b0:%d'%numvar)
B0=Matrix(Psi.cols,Bst.cols,b0)
RHS=Psi*B0
for i,j in product(range(B_hat.rows),range(B_hat.cols)): #diagonal explain later
SOL.update(solve_undetermined_coeffs(Eq(B_hat[i,j],RHS[i,j]),b0,s))
B0=B0.subs(SOL) #substitute(SOL)
LHS_matrix=simplify(Cs*C0) #left hand side of the equation (1)
sI_A=s*eye(A0.cols)- A0
max_degree=mc.find_degree(LHS_matrix,s) #get the degree of the matrix at the LHS
#which is also the maximum degree for the coefficients of Λ(s)
#---------------------------Creating Matrices Λ(s) and C -------------------------------------
Lamda=[]
numvar=((max_degree))*A0.cols
a=symbols('a0:%d'%numvar)
for i in range(A0.cols): # paratirisi den douleuei to prin giat;i otra oxi diagonios
p=sum(a[n +i*(max_degree)]*s**n for n in range(max_degree)) # we want variables one degree lower because we are multiplying by first order monomials
Lamda.append(p)
Lamda=Matrix(Cs.rows,A0.cols,Lamda) #convert the list to Matrix
c=symbols('c0:%d'%(Lamda.rows*Lamda.cols))
C=Matrix(Lamda.rows,Lamda.cols,c)
#-----------------------------------------
RHS_matrix=Lamda*sI_A +C #right hand side of the equation (1)
'''
-----------Converting equation (1) to a system of linear -----------
-----------equations, comparing the coefficients of the -----------
-----------polynomials in both sides of the equation (1) -----------
'''
EQ=[Eq(LHS_matrix[i,j],expand(RHS_matrix[i,j])) for i,j in product(range(LHS_matrix.rows),range(LHS_matrix.cols)) ]