def balanced(self): """ Returns an equivalent balanced state-space system Use ab09ad method from Slicot to get balanced state-space see http://slicot.org/objects/software/shared/doc/AB09AD.html Returns - a dSS object """ try: Nr, Ar, Br, Cr, hsv = ab09ad('D', 'B', 'N', self.n, self.q, self.p, self.A, self.B, self.C, nr=self.n, tol=1e-18) except NameError: raise ImportError("dSS.balanced: slycot is not installed") if Nr == 0: raise ValueError( "dSS: balanced: Cannot compute the balanced system " "(the selected order nr is greater than the order of a minimal realization of the given system)" ) return dSS(Ar, Br, Cr, self.D)
def order_reduced( self, dim, ) -> "DynamicQuantizer": """ Returns the quantizer with its order reduced. Note that the quantizer with the reduced order will generally have larger `E(Q)` and a larger `gain_wv` than those of the original quantizer. You should check the performance and gain yourself. This function requires slycot. Please install it. Parameters ---------- dim : int Order of the quantizer to be returned. Must be greater than `0` and less than `self.N`. Returns ------- Q : DynamicQuantizer Raises ------ ImportError if NQLib couldn't import slycot. """ try: from slycot import ab09ad except ImportError as e: raise ImportError(( "Reducing order of a quantizer requires slycot." " Please install it." )) # マルコフパラメータから特異値分解する Nr, Ar, Br, Cr, hsv = ab09ad( "D", # means "Discrete time" "B", # balanced (B) or not (N) "S", # scale (S) or not (N) self.N, # np.size(A,0) self.m, # np.size(B,1) self.m, # np.size(C,0) self.A, self.B, self.C, nr=dim, tol=0.0, ) return DynamicQuantizer(Ar, Br, Cr, self.q)
def balred(sys, orders, method='truncate'): """ Balanced reduced order model of sys of a given order. States are eliminated based on Hankel singular value. Parameters ---------- sys: StateSpace Original system to reduce orders: integer or array of integer Desired order of reduced order model (if a vector, returns a vector of systems) method: string Method of removing states, either ``'truncate'`` or ``'matchdc'``. Returns ------- rsys: StateSpace A reduced order model Raises ------ ValueError * if `method` is not ``'truncate'`` * if eigenvalues of `sys.A` are not all in left half plane (`sys` must be stable) ImportError if slycot routine ab09ad is not found Examples -------- >>> rsys = balred(sys, order, method='truncate') """ #Check for ss system object, need a utility for this? #TODO: Check for continous or discrete, only continuous supported right now # if isCont(): # dico = 'C' # elif isDisc(): # dico = 'D' # else: dico = 'C' #Check system is stable D,V = np.linalg.eig(sys.A) # print D.shape # print D for e in D: if e.real >= 0: raise ValueError("Oops, the system is unstable!") if method=='matchdc': raise ValueError ("MatchDC not yet supported!") elif method=='truncate': try: from slycot import ab09ad except ImportError: raise ControlSlycot("can't find slycot subroutine ab09ad") job = 'B' # balanced (B) or not (N) equil = 'N' # scale (S) or not (N) n = np.size(sys.A,0) m = np.size(sys.B,1) p = np.size(sys.C,0) Nr, Ar, Br, Cr, hsv = ab09ad(dico,job,equil,n,m,p,sys.A,sys.B,sys.C,nr=orders,tol=0.0) rsys = StateSpace(Ar, Br, Cr, sys.D) else: raise ValueError("Oops, method is not supported!") return rsys
def balred(sys, orders, method='truncate', alpha=None): """ Balanced reduced order model of sys of a given order. States are eliminated based on Hankel singular value. If sys has unstable modes, they are removed, the balanced realization is done on the stable part, then reinserted in accordance with the reference below. Reference: Hsu,C.S., and Hou,D., 1991, Reducing unstable linear control systems via real Schur transformation. Electronics Letters, 27, 984-986. Parameters ---------- sys: StateSpace Original system to reduce orders: integer or array of integer Desired order of reduced order model (if a vector, returns a vector of systems) method: string Method of removing states, either ``'truncate'`` or ``'matchdc'``. alpha: float Redefines the stability boundary for eigenvalues of the system matrix A. By default for continuous-time systems, alpha <= 0 defines the stability boundary for the real part of A's eigenvalues and for discrete-time systems, 0 <= alpha <= 1 defines the stability boundary for the modulus of A's eigenvalues. See SLICOT routines AB09MD and AB09ND for more information. Returns ------- rsys: StateSpace A reduced order model or a list of reduced order models if orders is a list Raises ------ ValueError * if `method` is not ``'truncate'`` or ``'matchdc'`` ImportError if slycot routine ab09ad, ab09md, or ab09nd is not found ValueError if there are more unstable modes than any value in orders Examples -------- >>> rsys = balred(sys, orders, method='truncate') """ if method != 'truncate' and method != 'matchdc': raise ValueError("supported methods are 'truncate' or 'matchdc'") elif method == 'truncate': try: from slycot import ab09md, ab09ad except ImportError: raise ControlSlycot( "can't find slycot subroutine ab09md or ab09ad") elif method == 'matchdc': try: from slycot import ab09nd except ImportError: raise ControlSlycot("can't find slycot subroutine ab09nd") #Check for ss system object, need a utility for this? #TODO: Check for continous or discrete, only continuous supported right now # if isCont(): # dico = 'C' # elif isDisc(): # dico = 'D' # else: dico = 'C' job = 'B' # balanced (B) or not (N) equil = 'N' # scale (S) or not (N) if alpha is None: if dico == 'C': alpha = 0. elif dico == 'D': alpha = 1. rsys = [] #empty list for reduced systems #check if orders is a list or a scalar try: order = iter(orders) except TypeError: #if orders is a scalar orders = [orders] for i in orders: n = np.size(sys.A, 0) m = np.size(sys.B, 1) p = np.size(sys.C, 0) if method == 'truncate': #check system stability if np.any(np.linalg.eigvals(sys.A).real >= 0.0): #unstable branch Nr, Ar, Br, Cr, Ns, hsv = ab09md(dico, job, equil, n, m, p, sys.A, sys.B, sys.C, alpha=alpha, nr=i, tol=0.0) else: #stable branch Nr, Ar, Br, Cr, hsv = ab09ad(dico, job, equil, n, m, p, sys.A, sys.B, sys.C, nr=i, tol=0.0) rsys.append(StateSpace(Ar, Br, Cr, sys.D)) elif method == 'matchdc': Nr, Ar, Br, Cr, Dr, Ns, hsv = ab09nd(dico, job, equil, n, m, p, sys.A, sys.B, sys.C, sys.D, alpha=alpha, nr=i, tol1=0.0, tol2=0.0) rsys.append(StateSpace(Ar, Br, Cr, Dr)) #if orders was a scalar, just return the single reduced model, not a list if len(orders) == 1: return rsys[0] #if orders was a list/vector, return a list/vector of systems else: return rsys
def balred(sys, orders, method='truncate', alpha=None): """ Balanced reduced order model of sys of a given order. States are eliminated based on Hankel singular value. If sys has unstable modes, they are removed, the balanced realization is done on the stable part, then reinserted in accordance with the reference below. Reference: Hsu,C.S., and Hou,D., 1991, Reducing unstable linear control systems via real Schur transformation. Electronics Letters, 27, 984-986. Parameters ---------- sys: StateSpace Original system to reduce orders: integer or array of integer Desired order of reduced order model (if a vector, returns a vector of systems) method: string Method of removing states, either ``'truncate'`` or ``'matchdc'``. alpha: float Redefines the stability boundary for eigenvalues of the system matrix A. By default for continuous-time systems, alpha <= 0 defines the stability boundary for the real part of A's eigenvalues and for discrete-time systems, 0 <= alpha <= 1 defines the stability boundary for the modulus of A's eigenvalues. See SLICOT routines AB09MD and AB09ND for more information. Returns ------- rsys: StateSpace A reduced order model or a list of reduced order models if orders is a list Raises ------ ValueError * if `method` is not ``'truncate'`` or ``'matchdc'`` ImportError if slycot routine ab09ad, ab09md, or ab09nd is not found ValueError if there are more unstable modes than any value in orders Examples -------- >>> rsys = balred(sys, orders, method='truncate') """ if method!='truncate' and method!='matchdc': raise ValueError("supported methods are 'truncate' or 'matchdc'") elif method=='truncate': try: from slycot import ab09md, ab09ad except ImportError: raise ControlSlycot("can't find slycot subroutine ab09md or ab09ad") elif method=='matchdc': try: from slycot import ab09nd except ImportError: raise ControlSlycot("can't find slycot subroutine ab09nd") #Check for ss system object, need a utility for this? #TODO: Check for continous or discrete, only continuous supported right now # if isCont(): # dico = 'C' # elif isDisc(): # dico = 'D' # else: dico = 'C' job = 'B' # balanced (B) or not (N) equil = 'N' # scale (S) or not (N) if alpha is None: if dico == 'C': alpha = 0. elif dico == 'D': alpha = 1. rsys = [] #empty list for reduced systems #check if orders is a list or a scalar try: order = iter(orders) except TypeError: #if orders is a scalar orders = [orders] for i in orders: n = np.size(sys.A,0) m = np.size(sys.B,1) p = np.size(sys.C,0) if method == 'truncate': #check system stability if np.any(np.linalg.eigvals(sys.A).real >= 0.0): #unstable branch Nr, Ar, Br, Cr, Ns, hsv = ab09md(dico,job,equil,n,m,p,sys.A,sys.B,sys.C,alpha=alpha,nr=i,tol=0.0) else: #stable branch Nr, Ar, Br, Cr, hsv = ab09ad(dico,job,equil,n,m,p,sys.A,sys.B,sys.C,nr=i,tol=0.0) rsys.append(StateSpace(Ar, Br, Cr, sys.D)) elif method == 'matchdc': Nr, Ar, Br, Cr, Dr, Ns, hsv = ab09nd(dico,job,equil,n,m,p,sys.A,sys.B,sys.C,sys.D,alpha=alpha,nr=i,tol1=0.0,tol2=0.0) rsys.append(StateSpace(Ar, Br, Cr, Dr)) #if orders was a scalar, just return the single reduced model, not a list if len(orders) == 1: return rsys[0] #if orders was a list/vector, return a list/vector of systems else: return rsys